*C# Unleashed*.

C# provides a complete set of language elements for writing expressions. An expression is a set of language elements combined to perform a meaningful computation. This article provides guidance on building C# expressions.

This article also demonstrates expressions created with each of C#'s built-in operators. All aspects of operators are covered to provide an understanding of their effects.

There are four types of operators—unary, binary, ternary, and a few others that don't fit into a category. Unary operators effect a single expression. Binary operators require two expressions to produce a result. The ternary operator has three expressions. The others can be explained only by reading each of their descriptions.

**For C++ and Java Programmers**

C# operators and their precedence are the same. No surprises here at all. If desired, you could skip this section without missing anything.

## Unary Operators

As previously stated, unary operators affect a single expression. In many
instances, the unary operators enable operations with simpler syntax than a
comparable binary operation. The unary operators include `+` (plus),
`-` (minus), `++` (increment), `--` (decrement), `!`
(logical negation), and `~` (bitwise complement).

**NOTE**

Mathematical operations on floating-point types are performed according to IEEE 754 arithmetic.

### The Plus Operator

The plus operator (`+`) has no effect on the expression it's used
with. Why would a language have an operator that has no effect? For consistency.
Most C# operators have a logical complement. Because there is a minus operator,
its logical complement is the plus operator. The `+` operator is
available to explicitly document code. Here are a couple examples:

int negative = -1; int positive = 1; int result; result = +negative; // result = -1 result = +positive; // result = 1

### The Minus Operator

The minus operator (`-`) allows negation of a variable's value.
In integer and decimal types, the result is the number subtracted from 0. For
floating-point types, the `-` operator inverts the sign of the number.
When a value is `NaN` (not a number), the result is still `NaN`.
Here are some examples:

int negInt = -1; decimal posDec = 1; float negFlt = -1.1f; double nanDbl = Double.NaN; int resInt; decimal resDec; float resFlt; double resDbl; resInt = -negInt; // resInt = 1 resDec = -posDec; // resDec = -1 resFlt = -negFlt; // resFlt = 1.1 resDbl = -nanDbl; // resDbl = NAN

### The Increment Operator

The increment operator (`++`) allows incrementing the value of a
variable by 1. The timing of the effect of this operator depends upon which side
of the expression it's on.

Here's a post-increment example:

int count; int index = 6; count = index++; // count = 6, index = 7

In this example, the `++` operator comes after the expression
`index`. That's why it's called a post-increment operator. The
assignment takes place, and then `index` is incremented. Because the
assignment occurs first, the value of `index` is placed into
`count`, making it equal to `6`. Then `index` is
incremented to become `7`.

Here's an example of a preincrement operator:

int count; int index = 6; count = ++index; // count = 7, index = 7

This time, the `++` operator comes before the expression
`index`. This is why it's called the preincrement operator.
`index` is incremented before the assignment occurs. Because
`index` is incremented first, its value becomes `7`. Next, the
assignment occurs to make the value of `count` equal to `7`.

### The Decrement Operator

The decrement operator (`--`) allows decrementing the value of a
variable. The timing of the effect of this operator again depends upon which
side of the expression it is on. Here's a post-decrement example:

int count; int index = 6; count = index--; // count = 6, index = 5

In this example, the `--` operator comes after the expression
`index`, and that's why it's called a post-decrement operator.
The assignment takes place, and then `index` is decremented. Because the
assignment occurs first, the value of `index` is placed into
`count`, making it equal to `6`. Then `index` is
decremented to become `5`.

Here's an example of a predecrement operator:

int count; int index = 6; count = --index; // count = 5, index = 5

This time the `--` operator comes before the expression
`index`, which is why it's called the predecrement operator.
`index` is decremented before the assignment occurs. Because
`index` is decremented first, its value becomes `5`, and then the
assignment occurs to make the value of `count` equal `5`.

### The Logical Complement Operator

A logical complement operator (`!`) serves to invert the result of a
Boolean expression. The Boolean expression evaluating to `true` will be
false. Likewise, the Boolean expression evaluating to `false` will be
true. Here are a couple examples:

bool bexpr = true; bool bresult = !bexpr; // bresult = false bresult = !bresult; // bresult = true

### The Bitwise Complement Operator

A bitwise complement operator (`~`) inverts the binary representation
of an expression. All 1 bits are turned to 0. Likewise, all 0 bits are turned to
1. Here's an example:

byte bitComp = 15; // bitComp = 15 = 00001111b byte bresult = (byte) ~bitComp; // bresult = 240 = 11110000b