Several common misunderstandings about the Equals method among C# beginners

Many C# textbooks will emphasize the concept of object equality. We all know that there are two kinds of equivalence in the world of C#. One is logical equivalence: if two objects logically represent the same value, they are said to have logical equivalence. The other is reference equality: if two references point to the same object instance, they are said to have reference equality.

　As we all know, the Object type has an instance method called Equals that can be used to determine whether two objects are equal. The default implementation of Object's Equals compares two objects for reference equality. The Object derived class ValueTpye overrides the Equals method, which compares the logical equality of two objects. That is, in C#, the default version of Equals for reference types focuses on reference equality, while value types focus on logical equality. Of course, this doesn't always meet our requirements. So whenever we care more about the logical equality of reference types, we should override the Equals method.

　A famous example of overriding the Equals method of a reference type to change its default comparison method is the String class. When we write code like string1.Equals(string2), we are not comparing whether the two references string1 and string2 point to the same instance (reference equality), but comparing the characters contained in string1 and string2. Whether the sequences are identical (logical equality).

　Misunderstanding 1: The Equals method and operator== have the same default behavior.

　For a reference type, if the == operator is not overloaded for it, and its parent type does not override the Equals method, the reference type's Equals method and operator== have the same default behavior, that is, they compare both Reference equality of objects. However, for value types, this is not the case at all! Because if you do not overload operator== for a custom value type, you cannot write code like myStruct1 == myStruct2, otherwise you will get a compilation error because the value type does not have a default implementation of the equality operator overload.

　Misunderstanding 2: The default implementation of the Equals method in a custom class will automatically call the operator== method, or the default implementation of the operator== method will automatically call the Equals method.

　We often hear people say that a certain type is a reference type, so the default implementation of its Equals method will automatically call the operator== method. This statement is completely unreasonable. As mentioned above, the default implementation of the Equals method of reference types comes from Object, while the default implementation of value types comes from TypeValue. Even if they use the == operator, they use an overloaded version of Object or TypeValue. In principle, as long as we do not override the Equals method of a class, it will inherit the implementation of its parent class, and the parent class has no chance to use subtype operator overloading. Similarly, as long as we do not call the Equals method in a class's == operator overload, it will not be called automatically.

　Misunderstanding 3: The default Equals implementation of value types compares two objects bit by bit.

Some people think that the default implementation of Equals for value types is to compare the bit representations of two objects in memory, that is, if all binary bits are equal, it means that the two objects are equal. This is not accurate. Because the default implementation of Equals for real value types is to call the Equals method of the field type for each field of the value type, they can only be equal if the Equals method of all fields returns true. Let’s look at an example:

class MyClass
{
     public override bool Equals(object obj)
    {
        Console.WriteLine("MyClass的Equals方法被调用了。");
        return true;
    }
}

struct MyStruct
{
     public MyClass Filed;
}

class Program
{
     staticvoid Main(string[] args)
     {
         MyStruct a;
         MyStruct b;
         a.Filed = new MyClass();
         b.Filed = new MyClass();
         Console.WriteLine(a.Equals(b));
      }
｝

Obviously, a and b have completely different binary bit representations. But the final printed result is:

The Equals method of MyClass was called.

True

This shows that the default implementation of value types determines whether two objects are equal by calling the Equals method of the field, rather than by comparing whether their binary bits are consistent.

　Misunderstanding 4: Equals is a very basic and commonly used method, so its default implementation does not have performance problems.

For reference types, the default implementation of Equals is very simple. You only need to determine whether two references are of the same type and whether the two references point to the same memory. So there is no problem with its performance. But for value types, Equals' task is not so simple. It requires comparing all fields of the two objects, that is, calling Equals of the field type field by field. Since in ValueType (where the Equals method of the value type is implemented by default), it is impossible to know which fields all its subtypes contain, so in order to call the Equals method of the subtype field, the Equals of ValueType needs to use reflection technology. As you may have noticed, reflection is not a performance-friendly technique, so the Equals method of value types is not efficient. This is why Microsoft recommends that we override the Equals method for custom value types.

For more related articles on several common misunderstandings of the Equals method among C# beginners, please pay attention to the PHP Chinese website!