Expressions and Operators

Sonali Gogate

C# Operators

The C# operator semantics, like the operator semantics in most of the
programming languages, follow the basic rules and notations of semantics of
mathematical operators.

The basic operators of C# are —

Addition (+)

Deletion (-)

Multiplication (*)

Division (/)

Modulus (%)

Assignment (=)

Also —

Unary Plus (+)

and

Unary Minus (-)

Most operators work only on numeric data types (like
int, float, double, long etc.) Exceptions to these are == and !=

Other C# operators are

+= (like C++, if we have a+=b, it means a = a+b)

++ (increment by 1)

-- (decrement by 1)

Using Operators in Expressions

When a single expression contains multiple operators, the execution sequence
is decided by the priority of each operator. The rules which a compiler follows
for determining the sequence of operator execution is known as "operator
precedence".

In case there are 2 operators of same "precedence", then the
evaluation is done based on its associativity (that is based on whether it is
left or right associative). For example in the following expression —

35 — 20 — 5

Since (-) is left-associative, (35-20)
gets evaluated to yield 15 and then
(15-5) is evaluated.

In C# all the binary operators except for = are left-associative.

= though is necessarily right-associative.

Operator Precedence in C#

Here is a table that shows the C# operators in descending operator
precedence —

If one wishes to change the evaluation of expressions (that is not evaluate
them in the order of precedence), it can be done with use of parentheses. For
example to change the evaluation order in the following expression and get the
addition done before the multiplication

6 + 3 * 4 — (this would evaluate to 18)

We can write it as

(6 + 3) * 4 — (this would evaluate to 36).

As you can see from the operators in the table above, most of them were
available in earlier languages like C++, and in that sense the operators and
expressions in C# are not any different from those in C++.

There are, a couple of operators, which I think are worth talking about —
specifically 2 primary operators, namely checked
and unchecked. These 2 are used to
control overflow checking of mathematical operations. We talk more about them
under "Error Handling".

(The author is a technical evangalist with Microsoft India)