OPERATORS:

Primary Operators
These are the highest precedence operators. NOTE, you can click on the operators to go the
detailed pages with examples.

x.y – member access.

x?.y – null conditional member access. Returns null if the left-hand operand is null.

x?[y] - null conditional index access. Returns null if the left-hand operand is null.

f(x) – function invocation.

a[x] – aggregate object indexing.

x++ – postfix increment. Returns the value of x and then updates the storage location with the
value of x that is one greater (typically adds the integer 1).

x-- – postfix decrement. Returns the value of x and then updates the storage location with the
value of x that is one less (typically subtracts the integer 1).

new – type instantiation.

typeof – returns the System.Type object representing the operand.

checked – enables overflow checking for integer operations.

unchecked – disables overflow checking for integer operations. This is the default compiler
behavior.

default(T) – returns the default value of type T, null for reference types, zero for numeric types,
and zero/null filled in members for struct types.

delegate – declares and returns a delegate instance.

sizeof – returns the size in bytes of the type operand.

-> – pointer dereferencing combined with member access.

Unary Operators
These operators have higher precedence than the next section and lower precedence than the
previous section. NOTE, you can click on the operators to go the detailed pages with examples.

+x – returns the value of x.

-x – numeric negation.

!x – logical negation.

~x – bitwise complement.

++x – prefix increment. Returns the value of x after updating the storage location with the value
of x that is one greater (typically adds the integer 1).

--x – prefix decrement. Returns the value of x after updating the storage location with the value
of x that is one less (typically adds the integer 1).

(T)x – type casting.

await – awaits a Task.

&x – address of.

*x – dereferencing.

Multiplicative Operators

These operators have higher precedence than the next section and lower precedence than the
previous section. NOTE, you can click on the operators to go the detailed pages with examples.

x * y – multiplication.

x / y – division. If the operands are integers, the result is an integer truncated toward zero (for
example, -7 / 2 is -3).

x % y – modulus. If the operands are integers, this returns the remainder of dividing x by y. If q
= x / y and r = x % y, then x = q * y + r.

Additive Operators

These operators have higher precedence than the next section and lower precedence than the
previous section. NOTE, you can click on the operators to go the detailed pages with examples.

x + y – addition.
x – y – subtraction.

Shift Operators

These operators have higher precedence than the next section and lower precedence than the
previous section. NOTE, you can click on the operators to go the detailed pages with examples.

x << y – shift bits left and fill with zero on the right.

x >> y – shift bits right. If the left operand is int or long, then left bits are filled with the sign bit.
If the left operand is uint or ulong, then left bits are filled with zero.

Relational and Type-testing Operators

These operators have higher precedence than the next section and lower precedence than the
previous section. NOTE, you can click on the operators to go the detailed pages with examples.

x < y – less than (true if x is less than y).

x > y – greater than (true if x is greater than y).

x <= y – less than or equal to.

x >= y – greater than or equal to.

is – type compatibility. Returns true if the evaluated left operand can be cast to the type specified
in the right operand (a static type).

as – type conversion. Returns the left operand cast to the type specified by the right operand (a
static type), but as returns null where (T)x would throw an exception.

Equality Operators

These operators have higher precedence than the next section and lower precedence than the
previous section. NOTE, you can click on the operators to go the detailed pages with examples.

x == y – equality. By default, for reference types other than string, this returns reference equality
(identity test). However, types can overload ==, so if your intent is to test identity, it is best to
use the ReferenceEquals method on object.

x != y – not equal. See comment for ==. If a type overloads ==, then it must overload !=.

Logical AND Operator

This operator has higher precedence than the next section and lower precedence than the
previous section. NOTE, you can click on the operator to go the details page with examples.

x & y – logical or bitwise AND. Use with integer types and enum types is generally allowed.

Logical XOR Operator

This operator has higher precedence than the next section and lower precedence than the
previous section. NOTE, you can click on the operator to go the details page with examples.

x ^ y – logical or bitwise XOR. You can generally use this with integer types and enum types.

Logical OR Operator

This operator has higher precedence than the next section and lower precedence than the
previous section. NOTE, you can click on the operator to go the details page with examples.

x | y – logical or bitwise OR. Use with integer types and enum types is generally allowed.

Conditional AND Operator

This operator has higher precedence than the next section and lower precedence than the
previous section. NOTE, you can click on the operator to go the details page with examples.

x && y – logical AND. If the first operand is false, then C# does not evaluate the second
operand.

Conditional OR Operator

This operator has higher precedence than the next section and lower precedence than the
previous section. NOTE, you can click on the operator to go the details page with examples.

x || y – logical OR. If the first operand is true, then C# does not evaluate the second operand.

Null-coalescing Operator

This operator has higher precedence than the next section and lower precedence than the
previous section. NOTE, you can click on the operator to go the details page with examples.

x ?? y – returns x if it is non-null; otherwise, returns y.

Conditional Operator
This operator has higher precedence than the next section and lower precedence than the
previous section. NOTE, you can click on the operator to go the details page with examples.

t ? x : y – if test t is true, then evaluate and return x; otherwise, evaluate and return y.

Assignment and Lambda Operators

These operators have higher precedence than the next section and lower precedence than the
previous section.

x = y – assignment.

x += y – increment. Add the value of y to the value of x, store the result in x, and return the new
value. If x designates an event, then y must be an appropriate function that C# adds as an event
handler.

x -= y – decrement. Subtract the value of y from the value of x, store the result in x, and return
the new value. If x designates an event, then y must be an appropriate function that C# removes
as an event handler

x *= y – multiplication assignment. Multiply the value of y to the value of x, store the result in x,
and return the new value.

x /= y – division assignment. Divide the value of x by the value of y, store the result in x, and
return the new value.

x %= y – modulus assignment. Divide the value of x by the value of y, store the remainder in x,
and return the new value.

x &= y – AND assignment. AND the value of y with the value of x, store the result in x, and
return the new value.

x |= y – OR assignment. OR the value of y with the value of x, store the result in x, and return the
new value.

x ^= y – XOR assignment. XOR the value of y with the value of x, store the result in x, and
return the new value.

x <<= y – left-shift assignment. Shift the value of x left by y places, store the result in x, and
return the new value.

x >>= y – right-shift assignment. Shift the value of x right by y places, store the result in x, and
return the new value.

=> – lambda declaration.

Arithmetic Overflow

The arithmetic operators (+, -, *, /) can produce results that are outside the range of possible
values for the numeric type involved. You should refer to the section on a particular operator for
details, but in general:

 Integer arithmetic overflow either throws an OverflowException or discards the most

significant bits of the result. Integer division by zero always throws
a DivideByZeroException.

When integer overflow occurs, what happens depends on the execution context, which can
be checked or unchecked. In a checked context, an OverflowException is thrown. In an
unchecked context, the most significant bits of the result are discarded and execution
continues. Thus, C# gives you the choice of handling or ignoring overflow. By default,
arithmetic operations occur in an unchecked context.

In addition to the arithmetic operations, integral-type to integral-type casts can cause

overflow (such as when you cast a long to an int), and are subject to checked or unchecked
execution. However, bitwise operators and shift operators never cause overflow.

 Floating-point arithmetic overflow or division by zero never throws an exception,

because floating-point types are based on IEEE 754 and so have provisions for
representing infinity and NaN (Not a Number).
 Decimal arithmetic overflow always throws an OverflowException. Decimal division by
zero always throws a DivideByZeroException.

Relational operators

using System;

class Program {

static void Main(string[] args) {

int a = 21;

int b = 10;

if (a == b) {

Console.WriteLine("Line 1 - a is equal to b");

} else {
 Console.WriteLine("Line 1 - a is not equal to b");

if (a < b) {

Console.WriteLine("Line 2 - a is less than b");

} else {

Console.WriteLine("Line 2 - a is not less than b");

if (a > b) {

Console.WriteLine("Line 3 - a is greater than b");

} else {

Console.WriteLine("Line 3 - a is not greater than b");

/* Lets change value of a and b */

a = 5;

b = 20;

if (a <= b) {

Console.WriteLine("Line 4 - a is either less than or equal to b");

if (b >= a) {

Console.WriteLine("Line 5-b is either greater than or equal to b");

}
Logical operators

using System;

namespace OperatorsAppl {

class Program {

static void Main(string[] args) {

bool a = true;

bool b = true;

if (a && b) {

Console.WriteLine("Line 1 - Condition is true");

if (a || b) {

Console.WriteLine("Line 2 - Condition is true");

/* lets change the value of a and b */

a = false;

b = true;

if (a && b) {

Console.WriteLine("Line 3 - Condition is true");

} else {

Console.WriteLine("Line 3 - Condition is not true");

}
 if (!(a && b)) {

Console.WriteLine("Line 4 - Condition is true");

Console.ReadLine();

Bitwise operator

using System;

namespace OperatorsAppl {

class Program {

static void Main(string[] args) {

int a = 60; /* 60 = 0011 1100 */

int b = 13; /* 13 = 0000 1101 */

int c = 0;

c = a & b; /* 12 = 0000 1100 */

Console.WriteLine("Line 1 - Value of c is {0}", c );

c = a | b; /* 61 = 0011 1101 */

Console.WriteLine("Line 2 - Value of c is {0}", c);

c = a ^ b; /* 49 = 0011 0001 */

Console.WriteLine("Line 3 - Value of c is {0}", c);

 c = ~a; /*-61 = 1100 0011 */

Console.WriteLine("Line 4 - Value of c is {0}", c);

c = a << 2; /* 240 = 1111 0000 */

Console.WriteLine("Line 5 - Value of c is {0}", c);

c = a >> 2; /* 15 = 0000 1111 */

Console.WriteLine("Line 6 - Value of c is {0}", c);

Console.ReadLine();