C# Tutorial – 05 – Operators

Operators are used to operate on values. They can be grouped into five types: arithmetic, assignment, comparison, logical and bitwise operators.

Arithmetic operators

The arithmetic operators include the four basic arithmetic operations, as well as the modulus operator (%) which is used to obtain the division remainder.

float x = 3 + 2; // 5 // addition
      x = 3 - 2; // 1 // subtraction
      x = 3 * 2; // 6 // multiplication
      x = 3 / 2; // 1 // division
      x = 3 % 2; // 1 // modulus (division remainder)

Notice that the division sign gives an incorrect result. This is because it operates on two integer values and will therefore round the result and return an integer. To get the correct value, one of the numbers needs to be converted into a floating-point number.

x = 3 / (float)2; // 1.5

Assignment operators

The second group is the assignment operators. Most importantly, the assignment operator (=) itself, which assigns a value to a variable.

Combined assignment operators

A common use of the assignment and arithmetic operators is to operate on a variable and then to save the result back into that same variable. These operations can be shortened with the combined assignment operators.

int x = 0;
    x += 5; // x = x+5;
    x -= 5; // x = x-5;
    x *= 5; // x = x*5; 
    x /= 5; // x = x/5;
    x %= 5; // x = x%5;

Increment and decrement operators

Another common operation is to increment or decrement a variable by one. This can be simplified with the increment (++) and decrement (--) operators.

x++; // x = x+1;
x--; // x = x-1;

Both of these operators can be used either before or after a variable.

x++; // post-increment
x--; // post-decrement
++x; // pre-increment
--x; // pre-decrement

The result on the variable is the same whichever is used. The difference is that the post-operator returns the original value before it changes the variable, while the pre-operator changes the variable first and then returns the value.

x = 5; y = x++; // y=5, x=6   
x = 5; y = ++x; // y=6, x=6

Comparison operators

The comparison operators compare two values and return either true or false. They are mainly used to specify conditions, which are expressions that evaluate into either true or false.

bool x = (2 == 3);  // false // equal to
     x = (2 != 3);  // true  // not equal to
     x = (2 > 3);   // false // greater than
     x = (2 < 3);   // true  // less than
     x = (2 >= 3);  // false // greater than or equal to
     x = (2 <= 3);  // true  // less than or equal to

Logical operators

The logical operators are often used together with the comparison operators. Logical and (&&) evaluates to true if both the left and right side are true, and logical or (||) evaluates to true if either the left or right side is true. The logical not (!) operator is used for inverting a Boolean result. Note that for both “logical and” and “logical or” the right side of the operator will not be evaluated if the result is already determined by the left side.

bool x = (true && false); // false // logical and
     x = (true || false); // true  // logical or
     x = !(true);         // false // logical not

Bitwise operators

The bitwise operators can manipulate individual bits inside an integer. For example, the bitwise and (&) operator makes the resulting bit 1 if the corresponding bits on both sides of the operator are set.

int x = 5 & 4;  // 101 & 100 = 100 (4) // and
    x = 5 | 4;  // 101 | 100 = 101 (5) // or
    x = 5 ^ 4;  // 101 ^ 100 = 001 (1) // xor
    x = 4 << 1; // 100 << 1  =1000 (8) // left shift
    x = 4 >> 1; // 100 >> 1  =  10 (2) // right shift
    x = ~4;     // ~00000100 = 11111011 (-5) // invert

These bitwise operators have shorthand assignment operators, just as the arithmetic operators.

int x=5; x &= 4; // 101 & 100 = 100 (4) // and
    x=5; x |= 4; // 101 | 100 = 101 (5) // or
    x=5; x ^= 4; // 101 ^ 100 = 001 (1) // xor
    x=5; x <<= 1;// 101 << 1  =1010 (10)// left shift
    x=5; x >>= 1;// 101 >> 1  =  10 (2) // right shift

Operator precedents

In C#, expressions are normally evaluated from left to right. However, when an expression contains multiple operators, the precedence of those operators decides the order in which they are evaluated.

For example, logical and (&&) binds weaker than relational operators, which in turn bind weaker than arithmetic operators.

bool x = 2+3 > 1*4 && 5/5 == 1; // true

To make things clearer, parentheses can be used to specify which part of the expression will be evaluated first. Parentheses have the highest precedence of all operators.

bool x = ((2+3) > (1*4)) && ((5/5) == 1); // true

Recommended reading:
C# 4.0 in a Nutshell - The Definitive Reference

PVT book:
Handbook of C# Syntax