C# Operators

C# provides a large set of operators, which are symbols that specify which operations to perform in an expression. Operations on integral types such as ==, !=, <, >, <=, >=, binary +, binary -, ^, &, |, ~, ++, --, and sizeof() are generally allowed on enumerations. In addition, many operators can be overloaded by the user, thus changing their meaning when applied to a user-defined type.

The following table lists the C# operators grouped in order of precedence. Operators within each group have equal precedence.

Operator category	Operators
Primary	x.y f(x) a[x] x++ x-- new typeof checked unchecked default(T) delegate sizeof ->
Unary	+x -x !x ~x ++x --x (T)x await &x *x
Multiplicative	x * y x / y x % y
Additive	x + y x - y
Shift	x << y x >> y
Relational and type testing	x < y x > y x <= y x >= y is as
Equality	x == y x != y
Logical AND	x & y
Logical XOR	x ^ y
Logical OR	x | y
Conditional AND	x && y
Conditional OR	x || y
Null-coalescing	x ?? y
Conditional	?:
Assignment and lambda expression	x = y x += y x -= y x *= y x /= y x %= y x &= y x |= y x ^= y x <<= y x >>= y =>

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.

• 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.

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.

In addition to the arithmetic operators, integral-type to integral-type casts can cause overflow, for example, casting a long to an int, and are subject to checked or unchecked execution. However, bitwise operators and shift operators never cause overflow.

See Also

Reference

Overloadable Operators (C# Programming Guide)

C# Keywords

Concepts

C# Programming Guide

Other Resources

C# Reference

Visual C#