Understand Virtual Object.Equals, Static Object.Equals and Reference.Equals in Object Class

public class Person
{
    private string _name;
    public string Name   
    {   
        get   
        {   
            return _name;   
        }   
    }
    public Person(string name)
    {
        _name = name;
    }

    public override string ToString()
    {
        return _name;
    }
}  

static void Main(String[] args)
{
    Person p1 = new Person("Ehsan Sajjad");
    Person p2 = new Person("Ahsan Sajjad");
    Console.WriteLine(p1.Equals(p2));
}

static void Main(String[] args)
{
    Person p1 = new Person("Ehsan Sajjad");
    Person p2 = new Person("Ahsan Sajjad");
    Person p3 = new Person("Ehsan Sajjad");
    
    Console.WriteLine(p1.Equals(p3));
}

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

    Console.WriteLine(s1.Equals((object)s2));
}

If we run the code, given above, will see that it returns true. The override provided by Microsoft for the string type compares the contents of the two string instances to check whether they contain exactly the same characters in the same sequence and returns true if they are, otherwise, it returns false, even if they are not the same instance.

There are not many Microsoft-defined reference types; for which Microsoft has overridden the Equals method to compare the values. Apart from the String type, two other types that you must be aware of are Delegate and Tuple.

Equals Method and Value Types

Now, we will see how the Equals method works for the value types. We will be using the same example that we used at the start of the post (Person class ), but we will change it to struct instead of the class to see the behavior in the case of the value type.

public struct Person
{
    private string _name;
    public string Name
    {
        get
        {
            return _name;
        }
    }
    public Person(string name)
    {
        _name = name;
    }
    public override string ToString()
    {
        return _name;
    }
}

What do you think will happen now, if we run the same program again, as we know struct is stored on the stack? They don’t have the references normally; unless we box them. This is the reason why they are called value types and not reference types.

static void Main(String[] args)
{
    Person p1 = new Person("Ehsan Sajjad");
    Person p2 = new Person("Ahsan Sajjad");
    Person p3 = new Person("Ehsan Sajjad");
    
    Console.WriteLine(p1.Equals(p2));
    Console.WriteLine(p1.Equals(p3));
}

Hence, as we know the implementation of Object. Equals are required to do the reference comparison in the case of the reference types, but in this case, you might think that comparing the references does not make sense as struct is a value type.

So let’s run the program and see what it prints on the console.

You can see, the result is different this time. For the second case; it is saying that both instances are equal. It is exactly the result you would expect; if you were to compare the values of both p1 and p3 instances of the person to see if they were equal, and that is actually happening in this case, but if we look at the Person type definition, we have not added any code to override the Equals method of Object class, which means there is nothing written in this type to tell the framework to compare the values of the instances of Person type to see if they are equal.

.NET already knows all that. It knows how to do this. The .NET framework has figured out without any effort from us how to tell if p1 and p3 have equal values or not, how is that happening? What is actually happening? As you already know, all struct types inherit from System.ValueType, which is ultimately derived from System.Object.

System.ValueType itself overrides the System. Object Equals method and what the override does is that it traverses all the fields in the value type and calls Equals against each one; until it either finds any field value that is different or all the fields are traversed. If all the fields turn out to be equal, then it figures out that these two value-type instances are equal. In other words, the value types override the Equals method implementation and say that both the instances are equal; if every field in them has the same value; which is quite sensible. In the above example, our Person type has only one field in it; which is the backing field for the Name property, which is of the typed string and we already know that calling Equals on the string compares the values and the above results of our program prove what we are stating here. That’s how .NET provides the behavior of the Equals method for the value types very nicely.

Equals method overhead for Value type

Unfortunately, this convenience provided by the .NET framework comes with a price. The Way System.ValueTypeequals implementation works by using reflection. Of course, it has to, if we think about it. As System.ValueType is a base type and it does not know how you will derive from it. Hence, the only way to find out what fields are in our defined type (in this case Person) is to do it using Reflection, which means that performance would be bad.

Recommended Approach with Value Types

The recommended way is to override the Equals method for your own value types; which we will see later; and how to provide that in a way that it runs faster. In fact, you will see that Microsoft has done that for many of the built-in value types that come with the framework which we use every day in our code.

Static Equals Method

There is one problem when checking if equality is being done using the virtual Equals method. What will happen if one or both of the references you want to compare is null. Let’s see what happens when we call the Equals method with null as an argument. Let’s modify the existing example for it:

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

If we compile this and run, it returns false and it makes perfect sense because it is obvious that null is not equal to a non-null instance and this is the principle of Equality in .NET, that Null should never be evaluated as equal to a Non-Null value.

Now, let’s make it vice versa to see what will happen if the p1 variable is null, then we have a problem. Consider, if we don’t have this hardcoded instance of creation code. Instead of it, this variable is passed as a parameter from some client code, which uses this assembly and we don’t know if either of the values is null or not.

If p1 is passed as null, executing the Equals method, a call will throw a Null Reference Exception, because you cannot call instance methods against the null instances.

The Static Equals method was designed to address this problem. Hence, we can use this method, if we are not aware if one of the objects could be null or not, and we can use it in the way shown below.

Console.WriteLine(object.Equals(p1, null));

Now, we are good to go without worrying about if either of the instance references is null or not. You can test it by running with both scenarios and you will see it works fine and of course, it would return false; if one of the reference variables is null.

Some of you may be wondering what would happen if both the arguments passed to the Static Equals method are null and if you add the following line to test it.

Console.WriteLine(object.Equals(null, null));

You will see that it returns true in this case. In .NET, null is always equal to null, so testing whether null is equal to null should always be evaluated to be true.

If we dig into the implementation of the Static Equals method, we will find that it is a very simple implementation. Following is the logic of it, if you look into the source code of Object type.

public static bool Equals(object x, object y)
{
    if (x == y) // Reference equality only; overloaded operators are ignored
    {
        return true;
    }
    if (x == null || y == null) // Again, reference checks
    {
        return false;
    }
    return x.Equals(y); // Safe as we know x != null.
}

It first checks if both the parameters refer to the same instance i.e. what the == operator will do. This check will evaluate to be true; causing the method to return true if both the parameters are null. The next if block will return false if one of the parameters is null and another one is not. Finally, if control reaches the else block, then we know that both the parameters point to some instance. Hence, we will just call the virtual Equals method.

This means that the static Equals method will always give the same result as the virtual method, except that it checks for null first, as a static method calls the virtual method. If we override the virtual Equals method, our override will automatically be picked by the static method, which is important, as we want both static and virtual methods to behave consistently.

ReferenceEquals Method

ReferenceEquals serves a slightly different purpose from the two Equals methods which we have discussed above. It exists for those situations where we specifically want to determine whether the two variables refer to the same instance or not. You may have a question in mind that if the Equals method also checks the reference equality then what is the need for a separate method?

These two methods do check reference equality, but they are not guaranteed to do so, because the virtual Equals method can be overridden to compare the values of the instance and not the reference.

Hence, ReferenceEquals will give the same result as Equals for the types that have not overridden the Equals method. For example, take the Person class example, which we used above. It’s possible to have different results for the types that have overridden the equals method. For Example, the String class.

Let’s modify the string class example that we used earlier in this post to demonstrate this.

static void Main(string[] args)
{
    string s1 = "Ehsan Sajjad";
    string s2 = string.Copy(s1);

    Console.WriteLine(s1.Equals((object)s2));
    Console.WriteLine(ReferenceEquals(s1, s2));
}

If we run this example, we will see that the first Equals call returns true just as shown before, but the ReferenceEquals method call returns false why is that?

It is telling us that both the string variables are different instances, even though they contain the same data recall what we discussed in the previous post String type overrides the Equals method to compare the value of two instances and not the reference.

You know that in C# static methods cannot be overridden, which means you can never change the behavior of the ReferenceEquals method, which makes sense because it always needs to do the reference comparison.

Summary

• We learned how .NET provides the types of equality implementation out of the box
• We saw that a few methods are defined by the .NET framework on the Object class, which is available for all the types.
• By default, the virtual Object.The equals method does reference equality for the reference types and the value equality for the value types by using reflection, which is a performance overhead for the value types.
• Any type can override an Object. Equals method to change the logic of how it checks for equality e.g. String, Delegate, and Tuple do this to provide the value equality, even though these are the reference types.
• Objects provide a static Equals method, which can be used when there is a chance that one or both of the parameters can be null, other than that, it behaves identically to the virtual Object. Equals method.
• There is also a static ReferenceEquals method, which provides a guaranteed way to check for reference equality.