# C# operators

C# provides many operators, which are symbols that specify which operations (math, indexing, function call, etc.) to perform in an expression. You can overload many operators to change their meaning when applied to a user-defined type.

Operations on integral types (such as `==`

, `!=`

, `<`

, `>`

, `&`

, `|`

) are generally allowed on enumeration (`enum`

) types.

The sections below list the C# operators starting with the highest precedence to the lowest. The operators within each section share the same precedence level.

## Primary operators

These are the highest precedence operators.

x.y – member access.

x?.y – null conditional member access. Returns `null`

if the left-hand operand evaluates to `null`

.

x?[y] - null conditional index access. Returns `null`

if the left-hand operand evaluates to `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 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) – produces the default value of type T.

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.

+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 subtracts the integer 1).

(T)x – type casting.

await – awaits a `Task`

.

&x – address of.

*x – dereferencing.

true operator - returns the bool value `true`

to indicate that an operand is definitely true.

false operator - returns the bool value `true`

to indicate that an operand is definitely false.

## Multiplicative operators

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

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 – remainder. 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.

x + y – addition.

x – y – subtraction.

## Shift operators

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

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

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.

`x & y`

– logical AND for the `bool`

operands or bitwise logical AND for the operands of the integral types.

## Logical XOR operator

This operator has higher precedence than the next section and lower precedence than the previous section.

`x ^ y`

– logical XOR for the `bool`

operands or bitwise logical XOR for the operands of the integral types.

## Logical OR operator

This operator has higher precedence than the next section and lower precedence than the previous section.

`x | y`

– logical OR for the `bool`

operands or bitwise logical OR for the operands of the integral types.

## Conditional AND operator

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

## Conditional OR operator

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

## Null-coalescing operator

x ?? y – returns `x`

if it is non-`null`

; otherwise, returns `y`

.

## Conditional operator

t ? x : y – if test `t`

evaluates to true, then evaluate and return `x`

; otherwise, evaluate and return `y`

.

## Assignment and Lambda operators

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 – remainder 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.

## See also

## Feedback

Send feedback about:

Loading feedback...