After reading,

 Story of Equality in .Net - Part 1  
 Story of Equality in .Net - Part 2

you can see that Object.Equals method has two problems. One thing is that it lacks strong typing and for value types boxing needs to be done. In this post we will look at the IEquatable<T> interface which provides solution to these problems.

The generic IEquatable <T> exists for solving a slightly different problem with Equals method. The Equals method on Object type takes parameter of type Object. We know that this is the only type of parameter which is possible if we want Object.Equals to work for all types.

But Object is a reference type which means that if you want to pace a value type as an argument, the value type would be boxed which will be a performance hit which is bad. Typically when we define value type instead of reference type is because we are concerned of performance, so we always want to avoid this performance overhead of boxing and unboxing.

There is also another problem, having an object as parameter means that there is no type safety. For Example, the following code will compile without any problem:

    class Program
    {
 
        static void Main(String[] args)
        {
            Person p1 = new Person("Ehsan Sajjad");
 
            Program p = new Program();
 
            Console.WriteLine(p1.Equals(p));
 
 
            Console.ReadKey();
        }        
 
    }

There is nothing to stop me for calling Equals method on two difference type of instances. We are comparing instance of Person class with instance of Program and compiler didn’t stopped me doing that, which is clearly an issue as both are totally different types and there is no way they can meaningfully equal each other.

IEquatable<T> and Value Types

        static void Main(String[] args)
        {
            int num1 = 5;
            int num2 = 6;
            int num3 = 5;
 
            Console.WriteLine(num1.Equals(num2));
            Console.WriteLine(num1.Equals(num3));

        }

We have three integer variables which we are comparing using Equals and printing the result on the console. If we look at the intellisense, we can see that there are two Equals method for int, one of them takes object as parameter and that’s the overridden Object.Equals method, other one takes an integer as parameter, this Equals method is implementation of IEquatable<int> by integer type, and this is the overload which will be used for comparison of the above example code, because in both Equals call we are passing integer as parameter not object, so the compiler will pick the overload defined for IEquatable<int> as it is the best signature match.


 This is obviously very unnatural way to compare integers, normally we just write like:

    Console.WriteLine(num1 == num2);

We have written the code via Equals method so that you can see that there are two Equals method out there. All primitive supports provide the implementation for IEquatable<T> interface. Just take the above example, int implements the IEquatable<int>.

IEquatable<T> and Reference Types

But it is worth noting here that String which is a reference type does implements IEquatable<T>.  If you recall from the Part – 2, when we were demonstrating the Equals method for string we were explicitly casting the string variable to object.

        static void Main(String[] args)
        {
            string s1 = "Ehsan Sajjad";
            string s2 = string.Copy(s1);
            
            Console.WriteLine(s1.Equals((object)s2));

        }

Summary

IEquatable<T> is implemented for  primitive numeric types but unfortunately Microsoft has not been very proactive  implementing for other value types in the Framework Class Library