C# 4 and .NET 4

162 ❘ ChaPTer 7 OperAtOrs And cAsts
ComParing objeCTs for equaliTy
After discussing operators and briefly touching on the equality operator, it is worth considering for a
moment what equality means when dealing with instances of classes and structs. Understanding the
mechanics of object equality is essential for programming logical expressions and is important when
implementing operator overloads and casts, which is the topic of the rest of this chapter.
The mechanisms of object equality are different depending on whether you are comparing reference types
(instances of classes) or value types (the primitive data types, instances of structs or enums). The following
sections present the equality of reference and value types independently.
Comparing reference Types for equality
You might be surprised to learn that System.Object defines three different methods for comparing objects
for equality: ReferenceEquals() and two versions of Equals(). Add to this the comparison operator
(==), and you actually have four ways of comparing for equality. Some subtle differences exist between the
different methods, which are examined next.
The referenceequals() Method
ReferenceEquals() is a static method that tests whether two references refer to the same instance
of a class, specifically whether the two references contain the same address in memory. As a static
method, it is not possible to override, so the System.Object implementation is what you always have.
ReferenceEquals() will always return true if supplied with two references that refer to the same object
instance, and false otherwise. It does, however, consider null to be equal to null:
SomeClass x, y;
x = new SomeClass();
y = new SomeClass();
bool B1 = ReferenceEquals(null, null);
bool B2 = ReferenceEquals(null,x);
bool B3 = ReferenceEquals(x, y);
The virtual equals() Method
// returns true
// returns false
// returns false because x and y
// point to different objects
The System.Object implementation of the virtual version of Equals() also works by comparing
references. However, because this method is virtual, you can override it in your own classes to compare
objects by value. In particular, if you intend instances of your class to be used as keys in a dictionary,
you will need to override this method to compare values. Otherwise, depending on how you override
Object.GetHashCode(), the dictionary class that contains your objects will either not work at all or will
work very inefficiently. One point you should note when overriding Equals() is that your override should
never throw exceptions. Once again, this is because doing so could cause problems for dictionary classes
and possibly certain other .NET base classes that internally call this method.
The static equals() Method
The static version of Equals() actually does the same thing as the virtual instance version. The difference
is that the static version takes two parameters and compares them for equality. This method is able to cope
when either of the objects is null, and, therefore, provides an extra safeguard against throwing exceptions
if there is a risk that an object might be null. The static overload first checks whether the references it has
been passed are null. If they are both null, it returns true (because null is considered to be equal to
null). If just one of them is null, it returns false. If both references actually refer to something, it calls the
virtual instance version of Equals(). This means that when you override the instance version of Equals(),
the effect is as if you were overriding the static version as well.
www.it-ebooks.info