C# 区别对待==和Equals，重写Equals

CLR中将“相等性”分为两类：“值相等性”和“引用相等性”。

值相等性：两个变量所包含的数值相等。

引用相等性：两个变量引用的是内存中的同一个对象。

无论是操作符“==”，还是方法“Equals()”，都倾向于表达这样一个原则：

对于值类型，如果类型的值相等，就应该返回true；

对于引用类型，如果类型指向同一个对象，则返回true。

例：

    class Program
    {
        static void Main(string[] args)
        {
            int i = 1;
            int j = 1;
            Console.WriteLine(i == j);      //true
            Console.WriteLine(i.Equals(j)); //true
            j = i;
            Console.WriteLine(i == j);      //true
            Console.WriteLine(i.Equals(j)); //true

            object a = new Person("NO1");
            object b = new Person("NO1");
            Console.WriteLine(a == b);      //false
            Console.WriteLine(a.Equals(b)); //false
            b = a;
            Console.WriteLine(a == b);      //true
            Console.WriteLine(a.Equals(b)); //true
            Console.Read();
        }
    }

    class Person
    {
        public string ID { get; private set; }
        public Person(string value)
        {
            ID = value;
        }
    }

操作符“==”，还是方法“Equals()”，都是可以被重载的。比如string类型，它是一个特殊的引用类型，微软觉得它的现实意义更接近于值类型，所以，再FCL中，string的比较被重载为针对”类型的值“的比较，而不是”引用本身“的比较。

例：

            string s1 = "aa";
            string s2 = "aa";
            Console.WriteLine(s1 == s2);      //true
            Console.WriteLine(s1.Equals(s2)); //true
            s2 = s1;
            Console.WriteLine(s1 == s2);      //true
            Console.WriteLine(s1.Equals(s2)); //true

从设计上来说，很多自定义类型（尤其是自定义的引用类型）会存在和string类型比较接近的情况。如第一个例子中的Person类，再现实生活中，如果两个人的ID是相等的，我们就会认为两者是同一个人，这个时候就要重载Equals方法了：

    class Person
    {
        public string ID { get; private set; }
        public Person(string value)
        {
            ID = value;
        }
        //重写Object.Equals(object o)
        public override bool Equals(object obj)
        {
            return ID == (obj as Person).ID;
        }
    }

这时再去比较两个具有相同ID的Person对象的值就会返回true:

     object a = new Person("NO1");
     object b = new Person("NO1");
     Console.WriteLine(a == b);      //false
     Console.WriteLine(a.Equals(b)); //true

此时，对于该类，可以用==判断两个实例是否为指向同一个对象，用Equals方法判断两个实例的值是否相等。

注意：FCL中提供了Object.ReferenceEquals方法来明确肯定是比较”引用相等性“。

 但是，重写了Equals方法，编译器会提示一个信息：

”重写 Object.Equals(object o)  但不重写 Object.GetHashCode()”

这样在使用FCL中的Dictionary类时，可能隐含一些潜在的Bug。

在上面的代码基础下，增加PersonMoreInfo类：

    class PersonMoreInfo
    {
        public string Info { get; set; }
        public PersonMoreInfo(string value)
        {
            Info = value;
        }
    }

创建一个Dictionary，通过key寻找value：

    class Program
    {
        static Dictionary<Person, PersonMoreInfo> PersonValues = new Dictionary<Person, PersonMoreInfo>();
        static void Main(string[] args)
        {
            AddPerson();
            Person mike = new Person("No2");
            Console.WriteLine(mike.GetHashCode());
            Console.WriteLine(PersonValues.ContainsKey(mike));//用key的HashCode寻找键

            Console.Read();
        }
        static void AddPerson()
        {
            Person mike = new Person("No2");
            PersonMoreInfo mikeValue = new PersonMoreInfo("Mike's info");
            PersonValues.Add(mike, mikeValue);
            Console.WriteLine(mike.GetHashCode());
            Console.WriteLine(PersonValues.ContainsKey(mike));
        }
    }

运行结果：

22008501
True
9008175
False

重写了Equals方法，所以在AddPerson方法里的mike和Main方法里的mike属于“值相等”，此时将“值”作为key放入Dictinoary中，再在某处根据mike将对应的键mikeValue取出来。但是上面代码运行结果却是Main方法中的mike没有对应的mikeValue。原因是键值对的集合会根据Key值的HashCode寻找Value值。CLR首先调用Person类的GetHashCode方法，因为Person类没有实现GetHashCode方法，所以就调用Object.GetHashCode()。Object为所有的CLR类型都提供了GetHashCode的默认实现，每new一个对象，CLR就会为该对象生成一个固定的整型值，该值在对象的生存周期内不会改变，GetHashCode方法就是实现对该整型值求HashCode。

所有上面的代码中，两个mike对象的HashCode是不一样的，导致Main方法里的mike没有对应的mikeValue。此时就要重写GetHashCode方法：

    class Person
    {
        public string ID { get; private set; }
        public Person(string value)
        {
            ID = value;
        }
        //重写Object.Equals(object o)
        public override bool Equals(object obj)
        {
            return ID == (obj as Person).ID;
        }
        //重写Object.GetHashCode()
        public override int GetHashCode()
        {
            return ID.GetHashCode();
        }
    }

再次运行代码得到以下结果：

-54312782
True
-54312782
True

因为HashCode一般作为对象的特征，在对象生存周期内赋值就不应改变，所以因基于那些只读属性或特性生成HashCode。

GetHashCode方法永远只返回一个整型int，而int的容量显然无法满足字符串的容量，以下代码会生成两个同样的HashCode：

      string s1 = "NB0903100006";
      string s2 = "NB0904140001";
      Console.WriteLine(s1.GetHashCode());
      Console.WriteLine(s2.GetHashCode());

所以为了减少两个不同类型之间根据字符串产生相同的HashCode几率，要改进GetHashCode方法：

        //重写Object.GetHashCode()
        public override int GetHashCode()
        {
            return (System.Reflection.MethodBase.GetCurrentMethod().
                DeclaringType.FullName + "#" + this.ID).GetHashCode();
        }

注意：重写Equals方法的同时，也应该实现一个类型安全的接口IEquatable<T>

    class Person : IEquatable<Person>
    {
        public string ID { get; private set; }
        public Person(string value)
        {
            ID = value;
        }
        //重写Object.Equals(object o)
        public override bool Equals(object obj)
        {
            return ID == (obj as Person).ID;
        }
        //重写Object.GetHashCode()
        public override int GetHashCode()
        {
            return (System.Reflection.MethodBase.GetCurrentMethod().
                DeclaringType.FullName + "#" + this.ID).GetHashCode();
        }
        //重写IEquatable<Person>.Equals(T other)
        public bool Equals(Person other)
        {
            return ID == other.ID;
        }
    }

参考：《编写高质量代码改善C#程序的157个建议》陆敏技