Microsoft.Net框架程序设计学习笔记（7）：重写Object.Equals方法

　　System.Object类型提供了名为Equals的虚方法，目的为判断两个对象是否有相同的“值”。.Net框架类库（FCL）中许多方法在内部都调用了Equals方法（如：Array的IndexOf方法、ArrayList的Contains方法）。对于没有显式重写Equals的类型，Object（或重写了Equals方法的最近的那基类）提供的实现将被继承。以下代码展示了System.Object类型中的Equals方法实现：

    class object
    {
        public virtual Boolean Equals(object obj)
        {
            //如果引用指向的是同一对象，肯定相等
            if (this == obj) return true;

            return false;
        }

        //......
    }

　　该方法采取的策略可能是最简单的：如果进行比较的两个引用指向的是同一个对象，方法将返回true；否则在任何其他情况下，方法都将返回false。如果我们定义了自己的类型，且希望比较它们中的字段是否相等，则Object类型提供的默认实现对我们来说是不够的，必须重写Equals方法。

　　实现Equals方法有3种不同方式，我们逐一讨论。

1. 为基类没有重写Object.Equals方法的引用类型实现Equals

       class MyRefType : BaseType
       {
           //引用类型字段
           RefType refobj;
           //值类型字段
           ValType valobj;
   
           public override bool Equals(object obj)
           {
               //如果obj为null，不可能相等
               if (obj == null) return false;
   
               //如果两个对象类型不同，不可能相等
               if (this.GetType() != obj.GetType()) return false;            MyRefType other = (MyRefType)obj;
   
               //比较其中的引用类型字段
               if (!object.Equals(refobj, other.refobj)) return false;
   
               //比较其中的值类型字段
               if (!valobj.Equals(other.valobj)) return false;
   
               return true;
           }
   
           //重载==和!=操作符
           public static Boolean operator ==(MyRefType o1, MyRefType o2)
           {
               return object.Equals(o1, o2);
           }
   
           public static Boolean operator !=(MyRefType o1, MyRefType o2)
           {
               return !(o1 == o2);
           }
       }

   在比较两个对象中的字段时，我们必须非常仔细。根据字段类型不同，比较方式亦不同。
   比较引用类型字段：
   比较引用类型字段时，我们应该调用object的静态Equals方法，该方法是比较两个引用类型对象的辅助方法，以下代码展示了该方法的内部实现：

           public static Boolean Equals(Object objA, Object objB)
           {
               //如果objA与objB指向同一个对象，返回true
               if (objA == objB) return true;
   
               //如果objA或objB为null，不可能相等
               if ((objA == null) || (objB == null)) return false;
   
               //判断objA与objB是否相等
               return objA.Equals(objB);
           }

   比较值类型字段：
   比较值类型字段，我们应该调用该字段类型的Equals方法来比较它们。不应该调用Object的静态Equals方法，因为值类型对象的值永远不可能为null，且调用object的静态Equals方法会对值类型对象执行装箱操作。
2. 为基类重写了Object.Equals方法的引用类型实现Euqals

   class MyRefType : BaseType
       {
           //引用类型字段
           RefType refobj;
           //值类型字段
           ValType valobj;
   
           public override bool Equals(object obj)
           {
               //首先让基类比较其中的字段
               if (!base.Equals(obj)) return false;

   　　　　　　//以下代码与上一节中的实现相同
   
             //如果obj为null，不可能相等
             if (obj == null) return false;
   
             //如果两个对象类型不同，不可能相等
             if (this.GetType() != obj.GetType()) return false;

             MyRefType other = (MyRefType)obj;

   　　　　　　//比较其中的引用类型字段
               if (!object.Equals(refobj, other.refobj)) return false;
   
               //比较其中的值类型字段
               if (!valobj.Equals(other.valobj)) return false;
   
               return true;
           }
   
           //重载==和!=操作符
           public static Boolean operator ==(MyRefType o1, MyRefType o2)
           {
               return object.Equals(o1, o2);
           }
   
           public static Boolean operator !=(MyRefType o1, MyRefType o2)
           {
               return !(o1 == o2);
           }

   }

   这段代码和前一节中展示的代码大体一样，唯一差别是这里还要求比较基类型中定义的字段。
   注意：如果调用base.Equals会导致调用object.Equals方法，那就不应该调用它。
3. 为值类型实现Equals方法
   所有的值类型都继承自System.ValueType。ValueType重写了Object的Equals方法实现。ValueType.Equals方法在内部首先使用反射机制来得到类型所有的实例字段，然后再比较它们是否相等。这种方法效率很低，但却是一个所有值类型都能继承的默认实现。下面的代码展示了System.ValueType.Equals方法的内部实现：

   class ValueType
       {
           public override bool Equals(object obj)
           {
               if (obj == null) return false;
   
               //得到this的类型
               Type thisType = this.GetType();
   
               if (thisType != obj.GetType()) return false;
   
               //取得该类型的所有公有和私有实例字段
               FieldInfo[] fields = thisType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
   
               for (int i = 0; i < fields.Length; i++)
               { 
                   //从两个对象中得到字段的值
                   object thisValue = fields[i].GetValue(this);
                   object thatValue = fields[i].GetValue(obj);
                   //如果字段值不等，返回false
                   if (!object.Equals(thisValue, thatValue)) return false;
               }
   
               return true;
           }
   
           //......
       }

   该方法已经提供了一个相当好的Equals实现，书中虽然介绍了自己提供强类型版本的Equals实现，但在该值类型与其他值类型之间存在隐式转换时，并不是一个好方法，下面仅列出代码供参考：

       struct MyValType
       {
           RefType refobj;
           ValType valobj;
   
           public override bool Equals(object obj)
           {
               if (!(obj is MyValType)) return false;
   
               return this.Equals((MyValType)obj);
           }
   
           //强类型版本Equals
           public Boolean Equals(MyValType obj)
           {
               if (!object.Equals(this.refobj, obj.refobj)) return false;
               if (!this.valobj.Equals(obj.valobj)) return false;
   
               return true;
           }
   
           //重载==操作符
           public static Boolean operator ==(MyValType v1, MyValType v2)
           {
               return v1.Equals(v2);
           }
   
           public static Boolean operator !=(MyValType v1, MyValType v2)
           {
               return !(v1 == v2);
           }
       }

　　题外话：关于Object.ReferenceEquals静态方法

　　Equals方法的目的是比较两个类型实例是否相等，如两个实例有相同的状态或值，则返回true。然而，有时我们需要判断两个引用是否指向了同一个对象，为实现这个功能，Object提供了一个名为ReferenceEquals的静态方法，它的实现如下：

class object
{
    public static Boolean ReferenceEquals(Object objA, Object objB)
    {
        return objA == objB;
    }
}

ClassA obj1 = new ClassA();
ClassA obj2 = obj1;

Console.WriteLine(Object.ReferenceEquals(obj1, obj2));

ClassA obj2 = new ClassA();
Console.WriteLine(Object.ReferenceEquals(obj1, obj2));