## #421 – Value Equality and IComparable Example

Here’s a full example of a reference type that supports value equality semantics and implements both IEquatable and IComparable.

```    public class Rectangle : IEquatable<Rectangle>, IComparable<Rectangle>
{
public int Height { get; set; }
public int Width { get; set; }

public Rectangle(int height, int width)
{
Height = height;
Width = width;
}

public override bool Equals(object obj)
{
return this.Equals(obj as Rectangle);
}

public override int GetHashCode()
{
return Height.GetHashCode() ^ Width.GetHashCode();
}

public bool Equals(Rectangle r)
{
if (ReferenceEquals(r,null))
return false;

return ((Height == r.Height) && (Width == r.Width) ||
(Height == r.Width) && (Width == r.Height));
}

public static bool operator ==(Rectangle r1, Rectangle r2)
{
if (ReferenceEquals(r1, null))
{
return ReferenceEquals(r2, null) ? true : false;
}

return r1.Equals(r2);
}

public static bool operator !=(Rectangle r1, Rectangle r2)
{
return !(r1 == r2);
}

// Result:
//  < 0 : this instance less than r
//  = 0 : this instance equivalent to r
//  > 0 : this instance greater than r
public int CompareTo(Rectangle r)
{
if (ReferenceEquals(r, null))
return 1;

if (this.Equals(r))
return 0;

else if (this.Area() == r.Area())
return this.Width - r.Width;

else
return this.Area() - r.Area();
}

public static bool operator <(Rectangle r1, Rectangle r2)
{
if (ReferenceEquals(r1, null))
return false;

else
return (r1.CompareTo(r2) < 0) ? true : false;
}

public static bool operator >(Rectangle r1, Rectangle r2)
{
if (ReferenceEquals(r1, null))
return false;

else
return (r1.CompareTo(r2) > 0) ? true : false;
}

public static bool operator <=(Rectangle r1, Rectangle r2)
{
return (r1 < r2) || (r1 == r2);
}

public static bool operator >=(Rectangle r1, Rectangle r2)
{
return (r1 > r2) || (r1 == r2);
}

public int Area()
{
return Height * Width;
}
}
```

## #420 – Laundry List for Implementing Value Equality and IComparable

To implement value equality (equivalence) in a reference type, you should do the following:

• Override Object.Equals
• In Object.Equals, call the type-specific Equals method using the as operator
• Implement IEquatable<T> by adding a type-specific Equals method
• Check for null using ReferenceEquals method
• Call base class’ Equals method to compare fields that exist in the base class if it also checks for value equality
• Check for equivalence by comparing individual fields
• Override GetHashCode, generating a hash code based on fields used for equivalence
• Check for 1st parameter being null, compare to 2nd parameter
• Call 1st parameter’s type-specific Equals method
• Overload != operator, invoking the == operator
• Implement IComparable<T>, adding a CompareTo method
• Check for equivalence using Equals method, then compare individual fields
• Overload < and > operators
• Check for 1st parameter being null
• Call 1st parameter’s CompareTo method
• Overload <= and >= operators
• Calculate a result using the <, > and == operators

## #414 – Equivalence Can Be Based on a Subset of Fields

When you define value equality for a type, you typically compare all fields in the two instances to determine whether they are equivalent.  You can also use just a subset of the fields in the comparison.

Below, two Programmer instances are equivalent if their Name and Age properties match.  But their Mood properties are not used in the comparison.

```    public class Programmer
{
public string Name { get; set; }
public int Age { get; set; }
public string Mood { get; set; }

// constructor omitted

public static bool operator ==(Programmer p1, Programmer p2)
{
return (p1.Name == p2.Name) && (p1.Age == p2.Age);
}

public static bool operator !=(Programmer p1, Programmer p2)
{
return !(p1 == p2);
}
}
```

Test results:

```            Programmer p1 = new Programmer("Sean", 47, "Elated");
Programmer p2 = new Programmer("Sean", 47, "Surly");
Programmer p3 = new Programmer("Bob", 47, "Surly");

bool check = (p1 == p2);        // true
check = (p2 == p3);             // false
```

## #406 – Overriding the Equals Method

You can override the Equals method in a custom type to implement value equality for two instances of the type.

Guidelines to follow when overriding Equals include:

• x.Equals(x) should return true
• x.Equals(y) should return the same value as y.Equals(x)
• x.Equals(y) and y.Equals(z) implies that x.Equals(z)
• Repeated calls to x.Equals(y) return the same result, for the same values of x and y
• x.Equals(null) returns false

• When you override Equals, you should also override GetHashCode

Here’s the implementation of Equals for the Dog class:

```        // Are two Dogs equivalent?
public override bool Equals(object obj)
{
// Can't be null
if (obj == null)
return false;

// Must be a Dog
if (obj is Dog)
{
// Compare the dogs
Dog d2 = (Dog)obj;
return (Name == d2.Name) && (Age == d2.Age);
}
else
return false;
}
```

Here’s the override of GetHashCode.

```        public override int GetHashCode()
{
return Name.GetHashCode() ^ Age;
}
```

## #402 – Value Equality vs. Reference Equality

When we normally think of “equality”, we’re thinking of value equality–the idea that the values stored in two different objects are the same.  This is also known as equivalence.  For example, if we have two different variables that both store an integer value of 12, we say that the variables are equal.

```            int i1 = 12;
int i2 = 12;

// Value equality - evaluates to true
bool b2 = (i1 == i2);
```

The variables are considered “equal”, even though we have two different copies of the integer value of 12.

We can also talk about reference equality, or identity–the idea that two variables refer to exactly the same object in memory.

```            Dog d1 = new Dog("Kirby", 15);
Dog d2 = new Dog("Kirby", 15);
Dog d3 = d1;

bool b1 = (d1 == d2);   // Evaluates to false
bool b2 = (d1 == d3);   // Evaluates to true
```

In C#, the == operator defaults to using value equality for value types and reference equality for reference types.