Understanding Operators

You use operators to combine operands together into expressions. Each operator has its own semantics dependent on the type it works with. For example, the + operator means “add” when used with numeric types, or “concatenate” when used with strings.

Each operator symbol has a precedence. For example, the * operator has a higher precedence than the + operator. This means that the expression a + b * c is the same as a + (b * c).

Each operator symbol also has an associativity to define whether the operator evaluates from left to right or from right to left. For example, the = operator is right-associative (it evaluates from right to left), so a = b = c is the same as a = (b = c).

NOTE
The right-associativity of the = operator allows you to perform multiple assignments in the same statement. For example, you can initialize several variables to the same value like this:
```int a, b, c, d, e;
a = b = c = d = e = 99;```
The expression e = 99 is evaluated first. The result of the expression is the value that was assigned (99), which is then assigned to d, c, b, and finally a in that order.

A unary operator is an operator that has just one operand. For example, the increment operator (++) is a unary operator.

A binary operator is an operator that has two operands. For example, the multiplication operator (*) is a binary operator.

Operator Constraints

C# allows you to overload most of the existing operator symbols for your own types. When you do this, the operators you implement automatically fall into a well-defined framework with the following rules:

• You cannot change the precedence and associativity of an operator. The precedence and associativity are based on the operator symbol (for example, +) and not on the type (for example, int) on which the operator symbol is being used. Hence, the expression a + b * c is always the same as a + (b * c), regardless of the type of a, b, and c.

• You cannot change the multiplicity of an operator (the number of operands). For example, * (the symbol for multiplication), is a binary operator. If you declare a * operator for your own type, it must be a binary operator.

• You cannot invent new operator symbols. For example, you can't create a new operator symbol, such as ** for raising one number to the power of another number. You'd have to create a method for that.

• You can't change the meaning of operators when applied to built-in types. For example, the expression 1 + 2 has a predefined meaning and you're not allowed to override this meaning. If you could do this, things would be too complicated!

• There are some operator symbols that you can't overload. For example, you can't overload the dot operator (member access). Again, if you could do this, it would lead to unnecessary complexity.

TIP
You can use indexers to simulate [ ] as an operator. Similarly, you can use properties to simulate = (assignment) as an operator, and you can use delegates to simulate a function call as an operator.

To define your own operator behavior, you must overload a selected operator. You use method-like syntax with a return type and parameters, but the name of the method is the keyword operator together with the operator symbol you are declaring. For example, here's a user-defined struct called Hour that defines a binary + operator to add together two instances of Hour:

```struct Hour
{
public Hour(int initialValue)
{
this.value = initialValue;
}

public static Hour operator+ (Hour lhs, Hour rhs)
{
return new Hour(lhs.value + rhs.value);
}
...
private int value;
}```

Notice the following:

• The operator is public. All operators must be public.

• The operator is static. All operators must be static. Operators are never polymorphic, and cannot use the virtual, abstract, override, or sealed modifiers.

• A binary operator (such as + shown above) has two explicit arguments and a unary operator has one explicit argument (C++ programmers should note that operators never have a hidden this parameter).

TIP
When declaring highly stylized functionality (such as operators), it is useful to adopt a naming convention for the parameters. For example, developers often use lhs and rhs (acronyms for left-hand side and right-hand side, respectively) for binary operators.

When you use the + operator on two expressions of type Hour, the C# compiler automatically converts your code into a call to the user-defined operator. The C# compiler converts this:

```Hour Example(Hour a, Hour b)
{
return a + b;
}```

Into this:

```Hour Example(Hour a, Hour b)
{
return Hour.operator+(a,b); // pseudocode
}```

Note, however, that this syntax is pseudocode and not valid C#. You can use a binary operator only in its standard infix notation (with the symbol between the operands).

There is one final rule you must follow when declaring an operator otherwise your code will not compile: At least one of the parameters should always be of the containing type. In the previous operator+ example for the Hour class, one of the parameters, a or b, must be an Hour object. In this example, both parameters are Hour objects. However, there could be times when you want to define additional implementations of operator+ that add an integer (a number of hours) to an Hour object—the first parameter could be Hour, and the second parameter could be the integer. This rule makes it easier for the compiler to know where to look when trying to resolve an operator invocation, and it also ensures that you can't change the meaning of the built-in operators.

Creating Symmetric Operators

In the previous section, you saw how to declare a binary + operator to add together two instances of type Hour. The Hour struct also has a constructor that creates an Hour from an int. This means that you can add together an Hour and an int—you just have to first use the Hour constructor to convert the int into an Hour. For example:

```Hour a = ...;
int b = ...;
Hour sum = a + new Hour(b);```

This is certainly valid code, but it is not as clear or as concise as adding together an Hour and an int directly, like this:

```Hour a = ...;
int b = ...;
Hour sum = a + b;```

To make the expression (a + b) valid, you must specify what it means to add together an Hour (a, on the left) and an int (b, on the right). In other words, you must declare a binary + operator whose first parameter is an Hour and whose second parameter is an int. The following code shows the recommended approach:

```struct Hour
{
public Hour(int initialValue)
{
this.value = initialValue;
}
...
public static Hour operator+ (Hour lhs, Hour rhs)
{
return new Hour(lhs.value + rhs.value);
}

public static Hour operator+ (Hour lhs, int rhs)
{
return lhs + new Hour(rhs);
}
...
private int value;
}```

Notice that all the second version of the operator does is construct an Hour from its int argument, and then call the first version. In this way, the real logic behind the operator is held in a single place. The point is that the extra operator+ simply makes existing functionality easier to use. Also, notice that you should not provide many different versions of this operator, each with a different second parameter type—only cater for the common and meaningful cases, and let the user of the class take any additional steps if an unusual case is required.

This operator+ declares how to add together an Hour as the left-hand operand and an int as the right-hand operator. It does not declare how to add together an int as the left-hand operand and an Hour as the right-hand operand:

```int a = ...;
Hour b = ...;
Hour sum = a + b; // compile-time error```

This is counter-intuitive. If you can write the expression a + b, you expect to also be able to write b + a. Therefore, you should provide another overload of operator+:

```struct Hour
{
public Hour(int initialValue)
{
this.value = initialValue;
}
...
public static Hour operator+ (Hour lhs, int rhs)
{
return lhs + new Hour(rhs);
}

public static Hour operator+ (int lhs, Hour rhs)
{
return new Hour(lhs) + rhs;
}
...
private int value;
}```
NOTE
C++ programmers should notice that you must provide the overload yourself. The compiler won't write it for you or silently swap the sequence of the two operands to find a matching operator.