Equality Features in .NET

facebooktwittergoogle_plusredditpinterestlinkedinmail

Introduction 

This article shows how .NET handles equality. I assume you are familiar with the “==” operator since I’m not discussing that here because that is a C# language feature, not .NET that has no concept of operators.

The .NET equality features are:

  • Virtual Object.Equals() method.
  • Static Object.Equals() method.
  • Static Object.ReferenceEquals method.
  • IEquatable<T> Interface

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

eq1

Virtual Object.Equals() method for reference types

This method gives you reference equality for most reference types, but the value equality for all value types.
I have a class called Person. The Person class has two the properties Id and Name and a constructor that forces me to set the Id and Name.

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

I have two instance of Person.

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”).

eq2

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

Virtual Object.Equals() method for value types

I have changed 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 I got 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();  
        }  
    }

eq3

How does Equals() work for values types?

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

eq4

Virtual equality method has one problem. What will happen when the reference is null?

eq5

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

Static Equals() Method

I have changed 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();  
 
   }  
}

I got the output as in the following:

eq6

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();  
 
        }  
    }

Here I have both Equals() and ReferenceEquals(). Both will return different output.

eq7

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

IEquatable Interface

As I said earlier, Equals() has some problems. In Figure 1 you 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 you to compare these two. To solve this problems Microsoft introduced the IEquatable interface. Here the Equals() method has a parameter with type T.

eq8

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

eq10

The Equals() method has two overloads for integers. You can see the System.Int32 struct in the following picture. The System.Int32 struct implements the IEquatable interface.

eqlast

IEquatable is very useful to a value type.

Conclusion

In this article you learned how the .NET Framework provides equality for value and reference types. I hope you like this article. Thanks for reading.

The following two tabs change content below.

Tom Mohan

Tom Mohan is a technologist who loves to code and build. He enjoys working on Microsoft Technologies. Tom specializes in ASP.NET MVC, Web API , Azure, C# ,WPF, SQL etc and holds a Bachelor engineering degree in Computer Science. Certification : MCSD , MCTS