C# - Operators: A Comprehensive Guide with Examples

In C#, operators are symbols that perform specific operations on one or more operands (variables, values, or expressions). They are fundamental to programming, enabling you to perform calculations, comparisons, logical evaluations, and more. This article will explore the different types of operators in C#, their usage, and practical examples to help you understand how they work.

Types of Operators in C#

C# provides a wide range of operators, which can be categorized into the following types:

1. Arithmetic Operators
2. Assignment Operators
3. Comparison Operators
4. Logical Operators
5. Bitwise Operators
6. Conditional Operator
7. Membership Operators

Let’s dive into each category with detailed explanations and examples.

1. Arithmetic Operators

Arithmetic operators are used to perform basic mathematical operations such as addition, subtraction, multiplication, division, and modulus (remainder).

int a = 10;
int b = 3;

int sum = a + b;        // Addition
int difference = a - b; // Subtraction
int product = a * b;    // Multiplication
int quotient = a / b;   // Division
int remainder = a % b;  // Modulus

Console.WriteLine($"Sum: {sum}");             // Output: Sum: 13
Console.WriteLine($"Difference: {difference}"); // Output: Difference: 7
Console.WriteLine($"Product: {product}");       // Output: Product: 30
Console.WriteLine($"Quotient: {quotient}");     // Output: Quotient: 3
Console.WriteLine($"Remainder: {remainder}");   // Output: Remainder: 1

Explanation:

• Addition (`+`): Adds two operands.
• Subtraction (`-`): Subtracts the second operand from the first.
• Multiplication (`*`): Multiplies two operands.
• Division (`/`): Divides the first operand by the second. If both operands are integers, the result is an integer (fractional part is discarded).
• Modulus (`%`): Returns the remainder after division.

2. Assignment Operators

Assignment operators are used to assign values to variables. They include the simple assignment operator (`=`) and compound assignment operators (`+=`, `-=`, `*=`, `/=`).

int a = 10;
int b;

b = a; // Simple assignment
Console.WriteLine($"Value of b: {b}"); // Output: Value of b: 10

a += 5; // Compound assignment (a = a + 5)
Console.WriteLine($"Value of a after +=: {a}"); // Output: Value of a after +=: 15

Explanation:

• Simple Assignment (`=`): Assigns the value on the right to the variable on the left.
• Compound Assignment (`+=`, `-=`, `*=`, `/=`): Performs an operation and assigns the result to the variable.

3. Comparison Operators

Comparison operators are used to compare two values or expressions. They return a boolean result (`true` or `false`).

int a = 5;
int b = 3;

bool isEqual = (a == b);          // Equal to
bool isNotEqual = (a != b);       // Not equal to
bool isGreater = (a > b);         // Greater than
bool isLess = (a < b);            // Less than
bool isGreaterOrEqual = (a >= b); // Greater than or equal to
bool isLessOrEqual = (a <= b);    // Less than or equal to

Console.WriteLine($"a == b: {isEqual}");                // Output: a == b: False
Console.WriteLine($"a != b: {isNotEqual}");             // Output: a != b: True
Console.WriteLine($"a > b: {isGreater}");               // Output: a > b: True
Console.WriteLine($"a < b: {isLess}");                  // Output: a < b: False
Console.WriteLine($"a >= b: {isGreaterOrEqual}");       // Output: a >= b: True
Console.WriteLine($"a <= b: {isLessOrEqual}");          // Output: a <= b: False

Explanation:

• Equal to (`==`): Checks if two operands are equal.
• Not equal to (`!=`): Checks if two operands are not equal.
• Greater than (`>`): Checks if the first operand is greater than the second.
• Less than (`<`): Checks if the first operand is less than the second.
• Greater than or equal to (`>=`): Checks if the first operand is greater than or equal to the second.
• Less than or equal to (`<=`): Checks if the first operand is less than or equal to the second.

4. Logical Operators

Logical operators are used to evaluate boolean expressions and make logical decisions.

bool a = true;
bool b = false;

bool logicalAnd = a && b;   // Logical AND
bool logicalOr = a || b;    // Logical OR
bool logicalNot = !a;       // Logical NOT

Console.WriteLine($"a && b: {logicalAnd}");   // Output: a && b: False
Console.WriteLine($"a || b: {logicalOr}");    // Output: a || b: True
Console.WriteLine($"!a: {logicalNot}");       // Output: !a: False

Explanation:

• Logical AND (`&&`): Returns `true` if both operands are `true`.
• Logical OR (`||`): Returns `true` if at least one operand is `true`.
• Logical NOT (`!`): Negates the value of the operand.

5. Bitwise Operators

Bitwise operators are used to perform operations on individual bits of integer values.

int a = 10; // Binary: 0000 1010
int b = 6;  // Binary: 0000 0110

int bitwiseAnd = a & b;    // Bitwise AND
int bitwiseOr = a | b;     // Bitwise OR
int bitwiseXor = a ^ b;    // Bitwise XOR
int bitwiseNotA = ~a;      // Bitwise NOT
int leftShift = a << 2;    // Left shift
int rightShift = a >> 2;   // Right shift

Console.WriteLine($"a & b: {bitwiseAnd}");           // Output: a & b: 2
Console.WriteLine($"a | b: {bitwiseOr}");            // Output: a | b: 14
Console.WriteLine($"a ^ b: {bitwiseXor}");           // Output: a ^ b: 12
Console.WriteLine($"~a: {bitwiseNotA}");             // Output: ~a: -11
Console.WriteLine($"a << 2: {leftShift}");           // Output: a << 2: 40
Console.WriteLine($"a >> 2: {rightShift}");          // Output: a >> 2: 2

Explanation:

• Bitwise AND (`&`): Performs a bitwise AND operation.
• Bitwise OR (`|`): Performs a bitwise OR operation.
• Bitwise XOR (`^`): Performs a bitwise exclusive OR operation.
• Bitwise NOT (`~`): Flips the bits of the operand.
• Left Shift (`<<`): Shifts bits to the left.
• Right Shift (`>>`): Shifts bits to the right.

6. Conditional Operator

The conditional operator (`? :`) is a shorthand for an `if-else` statement.

int a = 10;
int b = 5;

int max = (a > b) ? a : b; // Conditional operator

Console.WriteLine($"Maximum value: {max}"); // Output: Maximum value: 10

Explanation:

• The conditional operator evaluates a condition and returns one of two expressions based on whether the condition is `true` or `false`.

7. Membership Operators

Membership operators are used to check if a value exists in a collection or if an object is of a specific type.

string[] colors = { "Red", "Green", "Blue" };

bool containsRed = colors.Contains("Red");   // Membership check
bool containsYellow = colors.Contains("Yellow"); // Membership check

Console.WriteLine($"Contains Red: {containsRed}");           // Output: Contains Red: True
Console.WriteLine($"Contains Yellow: {containsYellow}");     // Output: Contains Yellow: False

Explanation:

• `in` Operator: Checks if a value exists in a collection.
• `is` Operator: Checks if an object is of a specific type.

Conclusion

Operators are the building blocks of C# programming, enabling you to perform a wide range of operations on data. By understanding the different types of operators and their usage, you can write more efficient and expressive code. Whether you're performing arithmetic calculations, making logical decisions, or manipulating bits, operators are essential tools in your C# toolkit.