public struct Latitude { // }

public struct Coordinate { public Coordinate(Longitude longitude, Latitude latitude) { _Longitude = longitude; _Latitude = latitude; } public Longitude Longitude { get { return _Longitude; } } private readonly Longitude _Longitude; public Latitude Latitude { get { return _Latitude; } } private readonly Latitude _Latitude; public override bool Equals(object obj) { // STEP 1: Check for null if (obj == null) { return false; } // STEP 3: equivalent data types if (thisGetType() != objGetType()) { return false; } return Equals((Coordinate)obj); } public bool Equals(Coordinate obj) { // STEP 1: Check for null if a reference type // (eg, a reference type) // if (obj == null) // { // return false; // } // // // // // // STEP 2: Check for ReferenceEquals if this is a reference type if ( ReferenceEquals(this, obj)) { return true; }

// // // // // // // // // // // // STEP 4: Possibly check for equivalent hash codes if (thisGetHashCode() != objGetHashCode()) { return false; } STEP 5: Check baseEquals if base overrides Equals() SystemDiagnosticsDebugAssert( baseGetType() != typeof(object) ); if ( !baseEquals(obj) ) { return false; }

// STEP 6: Compare identifying fields for equality // using an overload of Equals on Longitude return ( (LongitudeEquals(objLongitude)) && (LatitudeEquals(objLatitude)) ); } // STEP 7: Override GetHashCode public override int GetHashCode() { int hashCode = LongitudeGetHashCode(); hashCode ^= LatitudeGetHashCode(); // Xor (eXclusive OR) return hashCode; } }

In this implementation, the first two checks are relatively obvious Checks 4 6 occur in an overload of Equals() that takes the Coordinate data type specifically This way, a comparison of two Coordinates will avoid Equals(object obj) and its GetType() check altogether Since GetHashCode() is not cached and is no more efficient than step 5, the GetHashCode() comparison is commented out Similarly, baseEquals() is not used since the base class is not overriding Equals() (The assertion checks that base is not of type object, however it does not check that the base class overrides Equals(), which is required to appropriately call baseEquals()) Regardless, since GetHashCode() does not necessarily return a unique value (it only identifies when operands are different), on its own it does not conclusively identify equal objects

Like GetHashCode(), Equals() should also never throw any exceptions It is valid to compare any object with any other object, and doing so should never result in an exception

Guidelines for Implementing Equality While learning the details for overriding an object s virtual members, several guidelines emerge

Equals(), the == operator, and the != operator should be imple-

A type should use the same algorithm within Equals(), ==, and !=

When implementing Equals(), ==, and !=, a type s GetHashCode()

GetHashCode(), Equals(), ==, and != should never throw exceptions When implementing IComparable, equality-related methods should

The preceding section looked at overriding Equals() and provided the guideline that the class should also implement == and != The term for implementing any operator is operator overloading, and this section describes how to do this, not only for == and !=, but also for other supported operators For example, string provides a + operator that concatenates two strings This is perhaps not surprising, because string is a predefined type, so it could possibly have special compiler support However, C# provides for adding + operator support to a class or struct In fact, all operators are supported except xy, f(x), new, typeof, default, checked, unchecked, delegate, is, as, =, and => One particular noteworthy operator that cannot be implemented is the assignment operator; there is no way to change the behavior of the = operator