C# Basics: Why We Override Equals Method

You may have come across the following questions:

• Why override the Equals method?
• How to determine whether two objects are equal?
• How to determine whether two objects are identical?

To get an answer to all those questions, let us consider a Product class as listed next:

class Product
{
   public int Price { get; set; }
   public string Name { get; set; }

}

We are creating two instances of the Product class, foo and loo. The foo is assigned to loo. Both objects are pointing to the same reference, hence we will get true as the expected output for all the Equals.

Product foo = new Product {Price = 10,Name= "foo"};
Product loo = new Product();
loo = foo;
var valueEqual = foo.Equals(loo);
Console.WriteLine(valueEqual);

var objRefEqual= Object.ReferenceEquals(foo, loo);
Console.WriteLine(objRefEqual);

var objEqual = Object.Equals(foo,loo);
Console.WriteLine(objEqual);
Console.ReadKey(true);

The expected output is:



Now let us proceed and modify the instances as listed next:

Product foo = new Product {Price = 10,Name= "foo"};
Product loo = new Product();
loo.Price = 10;
loo.Name = "foo";
var valueEqual = foo.Equals(loo);
Console.WriteLine(valueEqual);

var objRefEqual= Object.ReferenceEquals(foo, loo);
Console.WriteLine(objRefEqual);

var objEqual = Object.Equals(foo,loo);
Console.WriteLine(objEqual);
Console.ReadKey(true);

This time you will get output as false for all the three Equals method.



However if you closely observe, the value of both of the properties of both objects are exactly the same. The Price and the Name properties are set to 100 and foo respectively. But still we are getting Equals returns false for the foo and the loo object.

We can observe that, even though the properties values are the same Equals returns false. Essentially, when arguments are referring to different objects Equals won't check for the values and always returns false. We can say that by default Equals check for identitical objects rather than equal objects.

Understanding Internal

To understand this behavior, let us examine the System.Object class. It contains:  

• One virtual Equals method.
  
  
• One static Equals method. This takes two arguments. It returns true if they are identical otherwise false.
  
  
• One static ReferenceEquals method. This takes two arguments. Returns true if both arguments are the same instance otherwise false.

Clearly the CLR Equals method does not check for the values, when the arguments refer to different objects. So by default it checks for the Object Identity rather than Object Equality.

Why to override Equals()

We may come across the requirement to check for object equality. To check whether both objects contain the same property value or not. This can be done by overriding the Equals method. We can override the Equals method as listed next:

class Product
{
    public int Price { get; set; }
    public string Name { get; set; }
    public override bool Equals(object obj)
    {
       if (obj == null)
            return false;
        if (this.GetType() != obj.GetType()) return false;

        Product p = (Product)obj;
        return (this.Price == p.Price) && (this.Name == p.Name);
    }
}

When overriding the Equals method, you should consider the following: 

• If an object argument is null, return false.
  
  
• If the type of an object argument is different than the type of this, return false.
  
  
• If the object argument is neither null nor its type is different then check for the values of the instance fields. If they are equal return true else return false.

We have overridden the Equals method, now if you compare the objects that are listed next, you will find that Equals returns true if Objects are equal whereas ReferenceEquals returns false when objects are different.

Product foo = new Product {Price = 10,Name= "foo"};
Product loo = new Product();
loo.Price = 10;
loo.Name = "foo";
var valueEqual = foo.Equals(loo);
Console.WriteLine(valueEqual);

var objRefEqual= Object.ReferenceEquals(foo, loo);
Console.WriteLine(objRefEqual);

var objEqual = Object.Equals(foo,loo);
Console.WriteLine(objEqual);
Console.ReadKey(true);

You will get the expected output true, false and true.



Summary

We started with the question, why override the Equals method? We learned that by default the System.Object Equals method does not check for the equality of the objects. It checks only for the object's identity. To check for object equality, we override the Equals method.