Skip to main content

2.4 - Operators in C#

Operators in C# are symbols that tell the compiler to perform specific mathematical or logical manipulations. They are essential for performing operations on variables and values in a C# program. This guide will cover the different types of operators available in C#, how they are used, and the rules that govern their behavior.

🔰 Beginner's Corner: What Are Operators?​

Think of operators as special symbols that perform actions on values, similar to how buttons on a calculator work:

  • The + button adds numbers together
  • The - button subtracts one number from another
  • The × button multiplies numbers
  • The ÷ button divides numbers

In programming, operators work the same way but can do even more things:

// Basic math operators
int sum = 5 + 3;        // Addition: sum becomes 8
int difference = 10 - 4; // Subtraction: difference becomes 6
int product = 3 * 7;     // Multiplication: product becomes 21
int quotient = 20 / 5;   // Division: quotient becomes 4

// Comparison operators
bool isEqual = (5 == 5);      // Equality: isEqual becomes true
bool isGreater = (10 > 5);    // Greater than: isGreater becomes true
bool isLess = (3 < 2);        // Less than: isLess becomes false

// Logical operators
bool bothTrue = true && true; // Logical AND: bothTrue becomes true
bool eitherTrue = true || false; // Logical OR: eitherTrue becomes true
bool notTrue = !true;         // Logical NOT: notTrue becomes false

💡 Concept Breakdown: Why We Need Operators​

Operators are essential because they allow your program to:

  1. Perform calculations - Like adding numbers or combining text
  2. Make decisions - By comparing values to determine what to do next
  3. Combine conditions - Using logical operators to create complex rules
  4. Modify values - Changing variables in a concise way

Without operators, even simple tasks would require many lines of code!

2.4.1 - Arithmetic Operators​

Arithmetic operators are used to perform mathematical operations such as addition, subtraction, multiplication, division, and remainder calculations. These operators form the foundation of numerical computations in C#.

2.4.1.1 - Basic Arithmetic Operators​

OperatorNameDescriptionExample
+AdditionAdds two operandsint sum = a + b;
-SubtractionSubtracts the right operand from the left operandint diff = a - b;
*MultiplicationMultiplies two operandsint product = a * b;
/DivisionDivides the left operand by the right operanddouble quotient = a / b;
%Modulus (Remainder)Returns the remainder after divisionint remainder = a % b;

2.4.1.2 - Increment and Decrement Operators​

OperatorNameDescriptionExample
++IncrementIncreases the value by 1a++ or ++a
--DecrementDecreases the value by 1a-- or --a

2.4.1.3 - Basic Examples​

// Initialize variables
int a = 10;
int b = 3;

// Basic arithmetic operations
int sum = a + b;        // 13
int difference = a - b; // 7
int product = a * b;    // 30
int quotient = a / b;   // 3 (integer division truncates the decimal part)
int remainder = a % b;  // 1 (10 divided by 3 gives 3 with remainder 1)

// Display results
Console.WriteLine($"Sum: {a} + {b} = {sum}");
Console.WriteLine($"Difference: {a} - {b} = {difference}");
Console.WriteLine($"Product: {a} * {b} = {product}");
Console.WriteLine($"Quotient: {a} / {b} = {quotient}");
Console.WriteLine($"Remainder: {a} % {b} = {remainder}");

2.4.1.4 - Integer vs. Floating-Point Division​

When performing division with integers, the result is truncated (the decimal part is discarded). To get a floating-point result, at least one of the operands must be a floating-point type.

// Integer division (result is truncated)
int x = 10;
int y = 3;
int intResult = x / y;  // 3 (decimal part is truncated)

// Floating-point division
double doubleResult = x / (double)y;  // 3.3333... (explicit cast to double)
float floatResult = (float)x / y;     // 3.3333... (explicit cast to float)

// Alternative approach using literal suffix
double result1 = 10.0 / 3;  // 3.3333... (10.0 is a double literal)
float result2 = 10f / 3;    // 3.3333... (10f is a float literal)

Console.WriteLine($"Integer division: {x} / {y} = {intResult}");
Console.WriteLine($"Floating-point division: {x} / (double){y} = {doubleResult}");

2.4.1.5 - Increment and Decrement Examples​

The increment (++) and decrement (--) operators can be used in two ways:

  • Prefix (++a, --a): The value is incremented/decremented before the expression is evaluated
  • Postfix (a++, a--): The value is incremented/decremented after the expression is evaluated
int i = 5;

// Postfix increment: use the current value, then increment
int postfixResult = i++;  // postfixResult = 5, i = 6
Console.WriteLine($"After postfix increment: i = {i}, result = {postfixResult}");

// Reset i
i = 5;

// Prefix increment: increment first, then use the new value
int prefixResult = ++i;  // prefixResult = 6, i = 6
Console.WriteLine($"After prefix increment: i = {i}, result = {prefixResult}");

// Reset i
i = 5;

// Postfix decrement: use the current value, then decrement
int postfixDecResult = i--;  // postfixDecResult = 5, i = 4
Console.WriteLine($"After postfix decrement: i = {i}, result = {postfixDecResult}");

// Reset i
i = 5;

// Prefix decrement: decrement first, then use the new value
int prefixDecResult = --i;  // prefixDecResult = 4, i = 4
Console.WriteLine($"After prefix decrement: i = {i}, result = {prefixDecResult}");

2.4.1.6 - Modulus Operator Applications​

The modulus operator (%) is particularly useful for:

  1. Checking if a number is even or odd
  2. Cycling through a range of values
  3. Formatting (e.g., time conversion)
// Check if a number is even or odd
int number = 7;
bool isEven = number % 2 == 0;  // false (7 is odd)
Console.WriteLine($"{number} is {(isEven ? "even" : "odd")}");

// Cycle through a range (useful for circular arrays, clock arithmetic, etc.)
int[] array = { 10, 20, 30, 40, 50 };
int index = 7;
int cyclicIndex = index % array.Length;  // 7 % 5 = 2
Console.WriteLine($"Element at cyclic index {index} is {array[cyclicIndex]}");

// Time conversion (hours on a 12-hour clock)
int hours = 25;
int clockHours = hours % 12;  // 25 % 12 = 1
if (clockHours == 0) clockHours = 12;  // Handle 0 as 12
Console.WriteLine($"{hours} hours on a 12-hour clock is {clockHours} o'clock");
Important Considerations
  1. Division by zero will throw a DivideByZeroException at runtime.
  2. Integer overflow can occur if the result of an arithmetic operation exceeds the range of the data type.
  3. Floating-point precision issues can arise due to the binary representation of decimal numbers.
  4. Order of operations follows standard mathematical precedence (PEMDAS: Parentheses, Exponents, Multiplication/Division, Addition/Subtraction).

2.4.2 - Comparison Operators​

Comparison operators are used to compare two values and return a boolean result (true or false). These operators are fundamental for decision-making in conditional statements and loops.

2.4.2.1 - Basic Comparison Operators​

OperatorNameDescriptionExample
==Equal toReturns true if operands are equalbool isEqual = (a == b);
!=Not equal toReturns true if operands are not equalbool notEqual = (a != b);
>Greater thanReturns true if left operand is greater than right operandbool isGreater = (a > b);
<Less thanReturns true if left operand is less than right operandbool isLess = (a < b);
>=Greater than or equal toReturns true if left operand is greater than or equal to right operandbool isGreaterOrEqual = (a >= b);
<=Less than or equal toReturns true if left operand is less than or equal to right operandbool isLessOrEqual = (a <= b);

2.4.2.2 - Basic Examples​

// Initialize variables
int a = 5;
int b = 10;
int c = 5;

// Equality comparison
bool isEqual = (a == c);        // true (5 equals 5)
bool notEqual = (a != b);       // true (5 is not equal to 10)

// Relational comparison
bool isGreater = (b > a);       // true (10 is greater than 5)
bool isLess = (a < b);          // true (5 is less than 10)
bool isGreaterOrEqual = (a >= c); // true (5 is equal to 5)
bool isLessOrEqual = (a <= b);  // true (5 is less than 10)

// Display results
Console.WriteLine($"a == c: {isEqual}");
Console.WriteLine($"a != b: {notEqual}");
Console.WriteLine($"b > a: {isGreater}");
Console.WriteLine($"a < b: {isLess}");
Console.WriteLine($"a >= c: {isGreaterOrEqual}");
Console.WriteLine($"a <= b: {isLessOrEqual}");

2.4.2.3 - Comparing Different Types​

When comparing values of different types, C# follows specific rules:

  1. Implicit Conversions: If one operand can be implicitly converted to the type of the other, the comparison is performed after conversion.
  2. Reference Types: For reference types, == and != compare references by default (whether they point to the same object), not the content.
  3. Value Types: For value types, == and != compare the actual values.
// Comparing different numeric types
int intValue = 10;
double doubleValue = 10.0;
bool compareNumeric = (intValue == doubleValue);  // true (implicit conversion)

// Comparing reference types (reference equality)
string str1 = "Hello";
string str2 = "Hello";
string str3 = new string(new char[] { 'H', 'e', 'l', 'l', 'o' });

bool compareStrings1 = (str1 == str2);  // true (string literals are interned)
bool compareStrings2 = (str1 == str3);  // true (string overrides == to compare content)

// Reference equality vs. content equality
object obj1 = new object();
object obj2 = new object();
object obj3 = obj1;

bool compareObjects1 = (obj1 == obj2);  // false (different objects)
bool compareObjects2 = (obj1 == obj3);  // true (same object)
bool compareObjects3 = object.ReferenceEquals(obj1, obj2);  // false
bool compareObjects4 = object.Equals(obj1, obj2);  // false

Console.WriteLine($"intValue == doubleValue: {compareNumeric}");
Console.WriteLine($"str1 == str2: {compareStrings1}");
Console.WriteLine($"str1 == str3: {compareStrings2}");
Console.WriteLine($"obj1 == obj2: {compareObjects1}");
Console.WriteLine($"obj1 == obj3: {compareObjects2}");

2.4.2.4 - Comparing Custom Types​

For custom types (classes and structs), you can override the equality behavior by:

  1. Overriding Equals() method
  2. Implementing IEquatable<T> interface
  3. Overloading == and != operators
/// <summary>
/// A simple Person class that demonstrates custom equality comparison
/// </summary>
public class Person : IEquatable<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    // Override Object.Equals
    public override bool Equals(object obj)
    {
        if (obj == null || GetType() != obj.GetType())
            return false;

        return Equals((Person)obj);
    }

    // Implement IEquatable<Person>
    public bool Equals(Person other)
    {
        if (other == null)
            return false;

        return Name == other.Name && Age == other.Age;
    }

    // Override GetHashCode (always override when overriding Equals)
    public override int GetHashCode()
    {
        return (Name, Age).GetHashCode();
    }

    // Overload == operator
    public static bool operator ==(Person left, Person right)
    {
        if (ReferenceEquals(left, null))
            return ReferenceEquals(right, null);

        return left.Equals(right);
    }

    // Overload != operator (always implement in pairs)
    public static bool operator !=(Person left, Person right)
    {
        return !(left == right);
    }
}

// Usage example
public void CompareCustomTypes()
{
    Person person1 = new Person("John", 30);
    Person person2 = new Person("John", 30);
    Person person3 = new Person("Jane", 25);

    // These will use our custom equality logic
    bool areEqual = person1 == person2;  // true (same name and age)
    bool notEqual = person1 != person3;  // true (different name and age)

    Console.WriteLine($"person1 == person2: {areEqual}");
    Console.WriteLine($"person1 != person3: {notEqual}");
}

2.4.2.5 - Comparison Operators in Conditional Statements​

Comparison operators are commonly used in conditional statements to control program flow:

int score = 85;

// If-else statement using comparison operators
if (score >= 90)
{
    Console.WriteLine("Grade: A");
}
else if (score >= 80)
{
    Console.WriteLine("Grade: B");
}
else if (score >= 70)
{
    Console.WriteLine("Grade: C");
}
else if (score >= 60)
{
    Console.WriteLine("Grade: D");
}
else
{
    Console.WriteLine("Grade: F");
}

// Switch expression with comparison (C# 8.0+)
string grade = score switch
{
    >= 90 => "A",
    >= 80 => "B",
    >= 70 => "C",
    >= 60 => "D",
    _ => "F"
};

Console.WriteLine($"Grade (using switch expression): {grade}");
Important Considerations
  1. Floating-point comparisons may not behave as expected due to precision issues. Use a small epsilon value for approximate equality.
  2. Reference type equality compares references by default, not content (except for string, which overrides the behavior).
  3. Always override GetHashCode() when overriding Equals() to maintain the general contract for hash codes.
  4. Implement IEquatable<T> for better performance when comparing custom types.
  5. Always implement == and != operators in pairs to maintain consistency.

2.4.3 - Logical Operators​

Logical operators are used to combine multiple boolean expressions or values and determine the logical relationship between them. These operators are essential for creating complex conditions in decision-making structures and control flow statements.

2.4.3.1 - Basic Logical Operators​

OperatorNameDescriptionExample
&&Logical ANDReturns true if both operands are truebool result = a && b;
||Logical ORReturns true if at least one operand is truebool result = a || b;
!Logical NOTReturns the opposite of the operand's valuebool result = !a;

2.4.3.2 - Basic Examples​

// Initialize boolean variables
bool condition1 = true;
bool condition2 = false;

// Logical AND (&&)
bool andResult = condition1 && condition2;  // false (both must be true)

// Logical OR (||)
bool orResult = condition1 || condition2;   // true (at least one must be true)

// Logical NOT (!)
bool notResult = !condition1;               // false (opposite of true)

// Display results
Console.WriteLine($"condition1 && condition2: {andResult}");
Console.WriteLine($"condition1 || condition2: {orResult}");
Console.WriteLine($"!condition1: {notResult}");

2.4.3.3 - Short-Circuit Evaluation​

C# uses short-circuit evaluation for logical operators, which means:

  • For && (AND): If the first operand evaluates to false, the second operand is not evaluated because the result will always be false.
  • For || (OR): If the first operand evaluates to true, the second operand is not evaluated because the result will always be true.

This behavior is important for performance and can be used to prevent potential errors:

// Short-circuit evaluation with AND
int x = 10;
bool result1 = (x > 0) && (10 / x > 1);  // Safe: division only happens if x > 0

// If x were 0, the second part wouldn't be evaluated, avoiding division by zero
x = 0;
bool result2 = (x > 0) && (10 / x > 1);  // Safe: second part is not evaluated

// Short-circuit evaluation with OR
string text = null;
bool result3 = (text != null) || (text.Length > 0);  // Safe: Length only checked if text is not null

Console.WriteLine($"Result 1: {result1}");
Console.WriteLine($"Result 2: {result2}");
Console.WriteLine($"Result 3: {result3}");

2.4.3.4 - Non-Short-Circuit Operators (& and |)​

C# also provides non-short-circuit versions of logical operators (& and |) that always evaluate both operands:

bool a = true;
bool b = false;

// Non-short-circuit AND
bool result1 = a & EvaluateAndPrint("b");  // Both operands are evaluated

// Non-short-circuit OR
bool result2 = a | EvaluateAndPrint("b");  // Both operands are evaluated

// Helper method that demonstrates evaluation
bool EvaluateAndPrint(string name)
{
    Console.WriteLine($"Evaluating {name}");
    return false;
}

2.4.3.5 - Logical Operators in Complex Conditions​

Logical operators are often used to create complex conditions in control structures:

// User authentication example
bool isRegistered = true;
bool hasValidCredentials = true;
bool isAdmin = false;
bool isAccountLocked = false;

// Complex condition using logical operators
if ((isRegistered && hasValidCredentials) && (!isAccountLocked))
{
    if (isAdmin)
    {
        Console.WriteLine("Welcome, Admin! You have full access.");
    }
    else
    {
        Console.WriteLine("Welcome, User! You have standard access.");
    }
}
else
{
    Console.WriteLine("Access denied. Please check your credentials or account status.");
}

2.4.3.6 - Logical Operators with Non-Boolean Operands (C# 8.0+)​

In C# 8.0 and later, logical operators can be used with non-boolean operands through pattern matching:

// Using logical operators with pattern matching (C# 8.0+)
object obj = "Hello";

// Logical AND with patterns
if (obj is string s && s.Length > 3)
{
    Console.WriteLine($"Object is a string with length > 3: {s}");
}

// Logical OR with patterns
if (obj is int i || obj is double d)
{
    Console.WriteLine("Object is either an int or a double");
}
else
{
    Console.WriteLine("Object is neither an int nor a double");
}

2.4.3.7 - Exclusive OR (XOR) with the ^ Operator​

The ^ operator can be used as a logical XOR (exclusive OR) when applied to boolean operands:

bool a = true;
bool b = false;

// Logical XOR: true if operands have different values
bool xorResult1 = a ^ b;  // true (operands are different)
bool xorResult2 = a ^ a;  // false (operands are the same)
bool xorResult3 = b ^ b;  // false (operands are the same)

Console.WriteLine($"true ^ false: {xorResult1}");
Console.WriteLine($"true ^ true: {xorResult2}");
Console.WriteLine($"false ^ false: {xorResult3}");

2.4.3.8 - Truth Tables​

Understanding truth tables is essential for working with logical operators:

Logical AND (&&)​

ABA && B
truetruetrue
truefalsefalse
falsetruefalse
falsefalsefalse

Logical OR (||)​

ABA || B
truetruetrue
truefalsetrue
falsetruetrue
falsefalsefalse

Logical NOT (!)​

A!A
truefalse
falsetrue

Logical XOR (^)​

ABA ^ B
truetruefalse
truefalsetrue
falsetruetrue
falsefalsefalse
Important Considerations
  1. Short-circuit evaluation can improve performance and prevent errors, but it can also hide bugs if you rely on side effects in the second operand.
  2. Operator precedence: ! has higher precedence than &&, which has higher precedence than ||. Use parentheses for clarity.
  3. De Morgan's Laws can be used to simplify logical expressions:
    • !(A && B) is equivalent to !A || !B
    • !(A || B) is equivalent to !A && !B
  4. Logical operators vs. bitwise operators: &&, ||, and ! are logical operators that work with boolean values, while &, |, and ~ are bitwise operators that work with individual bits.

2.4.4 - Bitwise Operators​

2.4.4.1 - Bitwise Operators in C#​

Bitwise operators perform operations on binary representations of numbers. They are used for operations that involve flags, masks, and shifts at the bit level.

Example Usage:

int a = 12; // 1100 in binary
int b = 10; // 1010 in binary
int resultAnd = a & b; // Bitwise AND
int resultOr = a | b; // Bitwise OR
int resultXor = a ^ b; // Bitwise XOR
int resultLeftShift = a << 2; // Left shift
int resultRightShift = a >> 2; // Right shift

Operators Covered:

  • & (Bitwise AND)
  • | (Bitwise OR)
  • ^ (Bitwise XOR)
  • << (Left shift)
  • >> (Right shift)

2.4.4.2 - Bitwise Operations Overview​

1. Binary Numbers and Base Systems

  • Understanding Binary (Base-2): Binary system uses two symbols, typically 0 and 1. Each position in a binary number represents a power of 2, with the rightmost position representing (2^0).
  • Conversion to and from Binary:
    • Decimal to Binary: Divide the decimal number by 2. Record the remainder as the least significant bit. Continue dividing the quotient by 2 until the quotient is 0. Read the remainders in reverse order.
    • Binary to Decimal: Multiply each bit by (2^n) where (n) is the position of the bit, starting from 0 at the rightmost bit. Sum all the results.

2. Bitwise AND, OR, XOR, NOT

  • AND (&): Compares each bit of its operands. Results in 1 if both bits are 1.
  • OR (|): Compares each bit of its operands. Results in 1 if at least one bit is 1.
  • XOR (^): Compares each bit of its operands. Results in 1 if the bits are different.
  • NOT (~): Flips all the bits in the operand.

3. Bitwise Shifts

  • Left Shift (<<): Shifts bits to the left, filling with 0s on the right. This operation is equivalent to multiplying by (2^n).
  • Right Shift (>>): Shifts bits to the right. For signed integers in C#, right shift is an arithmetic shift where the sign bit is used to fill vacancies.

4. Base Conversions From Decimal to Other Bases (e.g., Octal, Hexadecimal)

  • Decimal to Octal/Hexadecimal: Similar to converting to binary but divide by 8 for octal or 16 for hexadecimal. Use letters A-F for hexadecimal values 10-15.
  • Other Bases to Decimal: Similar to binary to decimal but multiply each digit by the base raised to the power of the position.

5. Overflow and Underflow

  • Overflow: Occurs when calculations exceed the maximum value the data type can hold.
  • Underflow: Happens when calculations fall below the minimum value.

6. Signed vs. Unsigned Integers

  • Understanding how negative numbers are handled (e.g., two's complement for signed integers).

7. Modular Arithmetic

  • Used in algorithms where numbers wrap around after reaching a certain value. Essential for understanding cyclic phenomena in computing.

2.4.4.3 - Practical Application Tips​

  • Use bitwise operations for efficiency: They are much faster than arithmetic operations for certain mathematical calculations.
  • Debugging: Be mindful of integer overflow and underflow, especially when using large numbers or negative values.
  • Security applications: Bitwise operations are common in cryptographic algorithms and hashing functions.

2.4.5 - Assignment Operators​

Assignment operators are used to assign values to variables. Apart from the simple assignment operator (=), C# provides compound assignment operators that combine arithmetic, bitwise, or logical operations.

Example Usage:

int x = 10;
x += 5; // x = x + 5
x *= 3; // x = x * 3
x &= 7; // x = x & 7
x |= 1; // x = x | 1
x ^= 4; // x = x ^ 4
x >>= 2; // x = x >> 2
x <<= 2; // x = x << 2

Operators Covered:

  • = (Simple assignment)
  • += (Add and assign)
  • -= (Subtract and assign)
  • *= (Multiply and assign)
  • /= (Divide and assign)
  • %= (Modulus and assign)
  • &= (AND and assign)
  • |= (OR and assign)
  • ^= (XOR and assign)
  • <<= (Left shift and assign)
  • >>= (Right shift and assign)

2.4.6 - Special Operators​

C# includes several special operators that perform various functions, such as the ternary conditional operator, null-coalescing operator, and more. Understanding these operators can greatly enhance your ability to write concise and readable code.

2.4.6.1 - Null-Coalescing Operator (??)​

The null-coalescing operator ?? is used to define a default value for nullable value types or reference types. It returns the left-hand operand if it is not null; otherwise, it returns the right-hand operand. This operator is particularly useful for handling nullable types and providing fallback values.

Syntax:

leftOperand ?? rightOperand

Example Usage:

int? nullableValue = null;
int value = nullableValue ?? 5; // value is 5 because nullableValue is null

string input = null;
string result = input ?? "Default Value"; // result is "Default Value" because input is null

Detailed Explanation:

In the example above, nullableValue is a nullable integer initialized to null. The expression nullableValue ?? 5 evaluates to 5 because nullableValue is null. Similarly, the input string is null, so input ?? "Default Value" evaluates to "Default Value".

The null-coalescing operator can be particularly useful when working with user inputs, configurations, or any scenario where a value might be missing, and a default needs to be provided.

2.4.6.2 - Null-Coalescing Assignment Operator (??=)​

The null-coalescing assignment operator ??= is used to assign a value to a variable if the variable is currently null. It combines the functionality of the null-coalescing operator with the assignment operator, simplifying the syntax needed to provide default values.

Syntax:

variable ??= value;

Example Usage:

int? nullableValue = null;
nullableValue ??= 5; // nullableValue is assigned to 5 because it was null

string input = null;
input ??= "Default Value"; // input is assigned to "Default Value" because it was null

Detailed Explanation:

In this example, nullableValue starts as null. The statement nullableValue ??= 5 checks if nullableValue is null, and since it is, assigns 5 to it. Similarly, input is null, so input ??= "Default Value" assigns "Default Value" to input.

The null-coalescing assignment operator is a shorthand for checking a variable for null and then assigning a value, thus reducing boilerplate code and improving readability.

2.4.6.3 - Null-Conditional Operator (?.)​

The null-conditional operator ?. allows you to access members (methods, properties, fields) or elements only if the operand on the left-hand side is not null. If the left-hand operand is null, the entire expression evaluates to null without throwing a NullReferenceException.

Syntax:

operand?.Member
operand?[index]

Example Usage:

System.Text.StringBuilder sb = null;
int? length = sb?.Length; // length is null because sb is null

List<int> numbers = null;
int? firstNumber = numbers?[0]; // firstNumber is null because numbers is null

Detailed Explanation:

In this example, sb is a StringBuilder object initialized to null. The expression sb?.Length safely attempts to access the Length property. Since sb is null, the result of sb?.Length is null rather than throwing a NullReferenceException.

Similarly, numbers is a list that is null. The expression numbers?[0] attempts to access the first element of the list. Since numbers is null, the result is null.

The null-conditional operator is very useful in preventing null reference exceptions and simplifying code that needs to handle nullable objects or collections.

2.4.6.4 - Combining Null-Coalescing and Null-Conditional Operators​

These operators can be combined to handle null values gracefully and provide default values if necessary.

Example Usage:

string[] strings = null;
int? length = strings?.Length ?? 0; // length is 0 because strings is null

System.Text.StringBuilder sb = null;
int lengthOrDefault = sb?.Length ?? 0; // lengthOrDefault is 0 because sb is null

Detailed Explanation:

In the first example, strings is an array initialized to null. The expression strings?.Length evaluates to null, and the null-coalescing operator ?? assigns the default value of 0 to length.

In the second example, sb is a StringBuilder object initialized to null. The expression sb?.Length evaluates to null, and the null-coalescing operator ?? assigns the default value of 0 to lengthOrDefault.

By combining these operators, you can write more concise and robust code that handles null values effectively. These special operators are fundamental tools in C#, enabling a wide range of functionality from simple conditionals to complex data handling operations. Mastery of these operators is essential for writing efficient and effective C# code.

2.4.7 - C# Operators Summary Table​

| Category            | Operator   | Description                                   | Example                  |
|---------------------|------------|-----------------------------------------------|--------------------------|
| Arithmetic          | `+`        | Addition                                      | `int sum = a + b;`       |
|                     | `-`        | Subtraction                                   | `int diff = a - b;`      |
|                     | `*`        | Multiplication                                | `int product = a * b;`   |
|                     | `/`        | Division                                      | `int quotient = a / b;`  |
|                     | `%`        | Modulus                                       | `int remainder = a % b;` |
| Comparison          | `==`       | Equal to                                      | `bool equal = a == b;`   |
|                     | `!=`       | Not equal to                                  | `bool notEqual = a != b;`|
|                     | `>`        | Greater than                                  | `bool greater = a > b;`  |
|                     | `<`        | Less than                                     | `bool less = a < b;`     |
|                     | `>=`       | Greater than or equal to                      | `bool ge = a >= b;`      |
|                     | `<=`       | Less than or equal to                         | `bool le = a <= b;`      |
| Logical             | `&&`       | Logical AND                                   | `bool and = a && b;`     |
|                     | `\|\|`     | Logical OR                                    | `bool or = a \|\| b;`    |
|                     | `!`        | Logical NOT                                   | `bool not = !a;`         |
| Bitwise             | `&`        | Bitwise AND                                   | `int and = a & b;`       |
|                     | `\|`       | Bitwise OR                                    | `int or = a \| b;`       |
|                     | `^`        | Bitwise XOR                                   | `int xor = a ^ b;`       |
|                     | `<<`       | Left shift                                    | `int left = a << 1;`     |
|                     | `>>`       | Right shift                                   | `int right = a >> 1;`    |
| Assignment          | `=`        | Simple assignment                             | `int x = 5;`             |
|                     | `+=`       | Add and assign                                | `x += 5;`                |
|                     | `-=`       | Subtract and assign                           | `x -= 5;`                |
|                     | `*=`       | Multiply and assign                           | `x *= 5;`                |
|                     | `/=`       | Divide and assign                             | `x /= 5;`                |
|                     | `%=`       | Modulus and assign                            | `x %= 5;`                |
|                     | `&=`       | AND and assign                                | `x &= 5;`                |
|                     | `\|=`      | OR and assign                                 | `x \|= 5;`               |
|                     | `^=`       | XOR and assign                                | `x ^= 5;`                |
|                     | `<<=`      | Left shift and assign                         | `x <<= 1;`               |
|                     | `>>=`      | Right shift and assign                        | `x >>= 1;`               |
| Special             | `??`       | Null-coalescing                               | `int y = x ?? -1;`       |
|                     | `??=`      | Null-coalescing assignment                    | `x ??= -1;`              |
|                     | `?.`       | Null-conditional                              | `int? len = str?.Length;`|
|                     | `?:`       | Ternary conditional                           | `int z = a > b ? a : b;` |

The above table encapsulates a concise overview of the operators discussed, providing quick reference to their syntax and typical use cases. This aids developers in recalling and implementing these operators effectively in their C# applications.

2.4.8 - Precedence of Operators in C#​

Operator precedence in C# determines the order in which parts of an expression are evaluated. In expressions with multiple operators, understanding precedence is crucial to ensure that the operations are performed in the expected order. Operators with higher precedence are evaluated before operators with lower precedence. When operators have the same precedence, associativity rules determine the order of evaluation, which can be either left-to-right or right-to-left.

Below is a summary table that outlines the precedence of operators in C#, from highest to lowest:

| Precedence | Operator                                                 | Description                                                   | Associativity      |
|------------|----------------------------------------------------------|---------------------------------------------------------------|--------------------|
| 1          | `.` `[]` `()` `->` `++` `--` `new`                       | Primary expressions, array and method calls                   | Left to Right      |
| 2          | `+` `-` `!` `~` `++` `--` `(T)x`                         | Unary plus and minus, logical and bitwise negation, type cast | Right to Left      |
| 3          | `*` `/` `%`                                              | Multiplication, division, modulus                             | Left to Right      |
| 4          | `+` `-`                                                  | Addition and subtraction                                      | Left to Right      |
| 5          | `<<` `>>`                                                | Shift operators                                               | Left to Right      |
| 6          | `<` `<=` `>` `>=`                                        | Relational operators                                          | Left to Right      |
| 7          | `==` `!=`                                                | Equality operators                                            | Left to Right      |
| 8          | `&`                                                      | Bitwise AND                                                   | Left to Right      |
| 9          | `^`                                                      | Bitwise XOR                                                   | Left to Right      |
| 10         | `|`                                                      | Bitwise OR                                                    | Left to Right      |
| 11         | `&&`                                                     | Logical AND                                                   | Left to Right      |
| 12         | `\|\|`                                                   | Logical OR                                                    | Left to Right      |
| 13         | `?:`                                                     | Ternary conditional                                           | Right to Left      |
| 14         | `=` `+=` `-=` `*=` `/=` `%=` `&=` `^=` `\|=` `<<=` `>>=` | Assignment operators                                          | Right to Left      |
| 15         | `,`                                                      | Comma operator                                                | Left to Right      |

Understanding this table helps in constructing expressions correctly, avoiding unintended order of operations, which is essential for achieving correct results and maintaining code clarity.

2.4.9 - Sample Code​

Below is a sample C# program that demonstrates the use of various operators, including arithmetic, comparison, logical, bitwise, and assignment operators.

using System;

namespace OperatorDemonstration
{
    class Program
    {
        static void Main(string[] args)
        {
            // Arithmetic Operators
            int a = 10, b = 3;
            Console.WriteLine($"Addition: {a} + {b} = {a + b}");
            Console.WriteLine($"Subtraction: {a} - {b} = {a - b}");
            Console.WriteLine($"Multiplication: {a} * {b} = {a * b}");
            Console.WriteLine($"Division: {a} / {b} = {a / b}");
            Console.WriteLine($"Modulus: {a} % {b} = {a % b}");

            // Increment and Decrement
            int c = 5;
            Console.WriteLine($"Original c: {c}");
            Console.WriteLine($"Post-increment: {c++}");
            Console.WriteLine($"Pre-increment: {++c}");
            Console.WriteLine($"Post-decrement: {c--}");
            Console.WriteLine($"Pre-decrement: {--c}");

            // Comparison Operators
            Console.WriteLine($"Equal to: {a} == {b} : {a == b}");
            Console.WriteLine($"Not equal to: {a} != {b} : {a != b}");
            Console.WriteLine($"Greater than: {a} > {b} : {a > b}");
            Console.WriteLine($"Less than: {a} < {b} : {a < b}");
            Console.WriteLine($"Greater than or equal to: {a} >= {b} : {a >= b}");
            Console.WriteLine($"Less than or equal to: {a} <= {b} : {a <= b}");

            // Logical Operators
            bool x = true, y = false;
            Console.WriteLine($"Logical AND: {x} && {y} : {x && y}");
            Console.WriteLine($"Logical OR: {x} || {y} : {x || y}");
            Console.WriteLine($"Logical NOT: !{x} : {!x}");

            // Bitwise Operators
            int m = 6; // Binary 110
            int n = 3; // Binary 011
            Console.WriteLine($"Bitwise AND: {m} & {n} : {m & n}"); // 2
            Console.WriteLine($"Bitwise OR: {m} | {n} : {m | n}");  // 7
            Console.WriteLine($"Bitwise XOR: {m} ^ {n} : {m ^ n}"); // 5
            Console.WriteLine($"Left Shift: {m} << 1 : {m << 1}");  // 12
            Console.WriteLine($"Right Shift: {m} >> 1 : {m >> 1}"); // 3

            // Assignment Operators
            int d = 10;
            d += 5; // Same as d = d + 5
            Console.WriteLine($"Add and assign: d += 5 : {d}");
            d *= 2; // Same as d = d * 2
            Console.WriteLine($"Multiply and assign: d *= 2 : {d}");

            // Ternary Conditional Operator
            int score = 82;
            string grade = score >= 90 ? "A" : "B";
            Console.WriteLine($"Ternary Conditional: Score: {score}, Grade: {grade}");

            // Null-coalescing Operator
            int? nullableInt = null;
            int regularInt = nullableInt ?? -1;
            Console.WriteLine($"Null-coalescing: {nullableInt} ?? -1 : {regularInt}");
        }
    }
}

Explanation of the Code:

  1. Arithmetic Operators: Demonstrates addition, subtraction, multiplication, division, and modulus.
  2. Increment and Decrement: Shows how to use post-increment, pre-increment, post-decrement, and pre-decrement operations.
  3. Comparison Operators: Used to compare two values.
  4. Logical Operators: Demonstrates AND, OR, and NOT operations.
  5. Bitwise Operators: Shows bitwise operations, including AND, OR, XOR, and bit shifts.
  6. Assignment Operators: Examples of using combined assignment operations to modify variables.
  7. Ternary Conditional Operator: A quick way to do conditional assignments.
  8. Null-coalescing Operator: Demonstrates how to use this operator with nullable types to provide default values.