Introduction 


The .NET equality features are:
The first 3 features are part of the System.Object class as in the following:

code object

Virtual Object.Equals() method for reference types


This method gives us reference equality for most reference types, but the value equality for all value types.

class Person 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public Person(int id ,string name) 
    
       this.Id = id; 
       this.Name = name; 
    
}


The Person class has two the properties Id and Name and a constructor that forces to set the Id and Name.

class Program 
{
    static void Main(string[] args) 
    
       Person Person1 = new Person(1,"Anil"); 
       Person Person2 = new Person(1, "Anil"); 
       Console.WriteLine(Person1.Equals(Person2)); 
       Console.ReadLine(); 
    
}

There are two instances, Person1 and Person2. Both are different instances but the values are the same (ID = 1 and Name = “Anil”).

false

Person1 and Person2 are different instances so the reference equality evaluates to false.

Virtual Object.Equals() method for value types


To demonstrate Virtual Object.Equals(), change the person class to a struct. We all know that class is a reference type and struct is a value type.

public struct Person 
   
       private int id; 
   
       public int Id 
       
           get { return id; } 
             
       
       private string name ; 
   
       public string Name 
       
           get { return name; } 
           
       
          
          
       public Person(int id ,string name) 
       
           this.id = id; 
           this.name = name; 
       
   }

There is no change in the Main Method, but different output, because Object.Equals() compares values for struct by default.

class Program 
    
        static void Main(string[] args) 
        
            Person Person1 = new Person(1,"Anil"); 
            Person Person2 = new Person(1, "Anil"); 
            Console.WriteLine(Person1.Equals(Person2)); 
            Console.ReadLine(); 
        
    }

true

Equals() is a virtual method of System. Object but inside the Value type class there is an override for Equals(). It checks all the fields and return true only if all fields are equal.

class type
Virtual equality method has one problem. It will throw an error for null reference

writ
If person1 is null then it will throw an error. We can overcome this issue using the Static Equals() method.

Static Equals() Method

Change the preceding program with static Equals().

class Program 
   static void Main(string[] args) 
   
      Person Person1 = null;// new Person(1, "Anil"); 
      Person Person2 = new Person(1, "Anil"); 
      Console.WriteLine(object.Equals(Person1, Person2)); 
      Console.ReadLine(); 
              
   
}

  Output:

false ouput

The following are the problems of the Equals() method:
  • Lack of strong typing 
  • Need to box value types.

Static Object.ReferenceEquals method

 

The ReferenceEquals method checks whether two variables refer to the same instance. Both the virtual Equals() and the static Equals() usually compare references but not if overridden. As we all know static methods are never overridable. So the static ReferenceEquals() behaviour cannot be changed.

Consider the following example. 

class Program
    {
        static void Main(string[] args)
        {
            //Person Person1 = null;// new Person(1, "Anil");
            //Person Person2 = new Person(1, "Anil");
            string person1 = "anil";
            string person2 = string.Copy(person1);
            Console.WriteLine(person1.Equals(person2));
            Console.WriteLine(Object.ReferenceEquals(person1,person2));
            Console.ReadLine();
               
        }
    }

Equals() and ReferenceEquals() will return different output.

tf

Equals() checks the value and ReferenceEquals() check the references.

IEquatable<T> Interface


  Equals() has some problems. In Figure 1 we can see Equals() has a parameter type object. It's a reference type, the value type will be boxed and that will give a performance hit. Equals() is not type-safe.
class Program 
    
        static void Main(string[] args) 
        
            Person Person1 = new Person(1, "Anil"); 
            List<int> list = new List<int>(); 
            Console.WriteLine(Person1.Equals(list)); 
            Console.ReadLine(); 
              
        
    }

In the preceding example “Person1” is a type of Person class and “list” is a list of integers. Both are totally different. But the compiler allows us to compare these two. To solve this problems Microsoft introduced the IEquatable<T> interface. Here the Equals() method has a parameter with type T.

green code

This would solve boxing and type safety. See the following picture:

boolean equals

void main boolean
The Equals() method has two overloads for integers. We can see the System.Int32 struct in the following picture. The System.Int32 struct implements the IEquatable<T> interface. 

namespace system
IEquatable<T> is very useful to a value type.



See Also


.NET: Best Approach Implementing equality comparison