C# 4 and .NET 4

operator overloading ❘ 163
Comparison operator (==)
It is best to think of the comparison operator as an intermediate option between strict value comparison and
strict reference comparison. In most cases, writing the following means that you are comparing references:
bool b = (x == y); // x, y object references
However, it is accepted that there are some classes whose meanings are more intuitive if they are treated
as values. In those cases, it is better to override the comparison operator to perform a value comparison.
Overriding operators is discussed next, but the obvious example of this is the System.String class
for which Microsoft has overridden this operator to compare the contents of the strings rather than
their references.
Comparing Value Types for equality
When comparing value types for equality, the same principles hold as for reference types:
ReferenceEquals() is used to compare references, Equals() is intended for value comparisons, and the
comparison operator is viewed as an intermediate case. However, the big difference is that value types need
to be boxed to be converted to references so that methods can be executed on them. In addition, Microsoft
has already overloaded the instance Equals() method in the System.ValueType class to test equality
appropriate to value types. If you call sA.Equals(sB) where sA and sB are instances of some struct, the
return value will be true or false, according to whether sA and sB contain the same values in all their
fields. On the other hand, no overload of == is available by default for your own structs. Writing (sA ==
sB) in any expression will result in a compilation error unless you have provided an overload of == in your
code for the struct in question.
Another point is that ReferenceEquals() always returns false when applied to value types because, to
call this method, the value types need to be boxed into objects. Even if you write the following, you will still
get the answer of false:
bool b = ReferenceEquals(v,v); // v is a variable of some value type
The reason for this is that v will be boxed separately when converting each parameter, which means you get
different references. Because of this, there really is no reason to call ReferenceEquals() to compare value
types because it doesn’t make much sense.
Although the default override of Equals() supplied by System.ValueType will almost certainly be
adequate for the vast majority of structs that you define, you might want to override it again for your own
structs to improve performance. Also, if a value type contains reference types as fields, you might want
to override Equals() to provide appropriate semantics for these fields because the default override of
Equals() will simply compare their addresses.
oPeraTor oVerloading
This section looks at another type of member that you can define for a class or a struct: the operator overload.
Operator overloading is something that will be familiar to C++ developers. However, because the concept
will be new to both Java and Visual Basic developers, we explain it here. C++ developers will probably
prefer to skip ahead to the main operator overloading example.
The point of operator overloading is that you do not always just want to call methods or properties on
objects. Often, you need to do things like adding quantities together, multiplying them, or performing
logical operations such as comparing objects. Suppose that you had defined a class that represents a
mathematical matrix. Now in the world of math, matrices can be added together and multiplied, just like
numbers. Therefore, it is quite plausible that you would want to write code like this:
Matrix a, b, c;
// assume a, b and c have been initialized
Matrix d = c * (a + b);
www.it-ebooks.info