Export (0) Print
Expand All

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

=>

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.

Show:
© 2014 Microsoft