C#：Equals, ReferenceEquals与==的区别

==运算符：对于值类型，如果操作数的值相等，则==返回true，否则返回false。对于string以外的引用类型，如果两个对象引用同一个对象，则==返回true。对于string类型，==比较字符串的值。

using System;
class MainClass
{
    static void Main()
    {
        // Numeric equality: True
        Console.WriteLine((2 + 2) == 4);//return true，这里比较的是值相等

        // Reference equality: different objects, 
        // same boxed value: False.
        object s = 1;
        object t = 1;
        Console.WriteLine(s == t);//return false，这里比较的是引用相等
        Console.WriteLine(s.Equals(t).ToString());//return true，这里比较的是值相等


        // Define some strings:
        string a = "hello";
        string b = String.Copy(a); //注意：这里的Copy方法将在堆中创建一个新对象， 并将a的值拷贝到b中，也就是说a，b的值虽然相同，但是引用却不相同，a和b是不同的对象
        string c = "hello"; //注意：这的操作设计到string的一个优化策略，对于string类型的两个变量a和c，如果系统发现a和c的内容相同，则直接将a的引用赋给c；
        //也就是说a和c的引用指向的是同一对象。（相同的引用肯定有相同的值，但是相同值却不一定有相同的引用）

        // Compare string values of a constant and an instance: True
        Console.WriteLine(a == b);//return true，string比较特殊，string的很多方法被重写过， 这里比较的是值相等，即内容相等
        Console.WriteLine(a.Equals(b).ToString()); //return true，这里比较的是值相等，Equals()方法是string上的方法

        // Compare string references; 
        // a is a constant but b is an instance: False.
        Console.WriteLine((object)a == (object)b);/*return false，这里比较的是引用相等，因为string的==操作被重写过，所以强转为object类型后再比较其引用。
                                                   因为b创建新的对象， 所以虽然a和b的值相同，但终究是不同的引用*/
        Console.WriteLine((object)a.Equals((object)b).ToString()); //return true，这里比较的是值相等, Equals()方法是string上的方法

        // Compare string references, both constants 
        // have the same value, so string interning
        // points to same reference: True.
        Console.WriteLine((object)a == (object)c);//return true，这里的a和c的值相同，那么编译器认为a和c指向同一个引用
        Console.WriteLine((object)a.Equals((object)c).ToString()); //return true，这里比较的是值相等，Equals()方法是string上的方法
    }
}

引用类型的比较：

using System;

namespace ConsoleApplication14
{
    class Program
    {
        static void Main(string[] args)
        {
            ReferneceClass c1 = new ReferneceClass();
            c1.X = 1;
            c1.Y = "OK";

            ReferneceClass c2 = new ReferneceClass();
            c2.X = 1;
            c2.Y = "OK";

            ReferneceClass c3 = new ReferneceClass();
            c3.X = 1;
            c3.Y = "OK!";

            ReferneceClass c4 = new ReferneceClass();
            c4.X = 2;
            c4.Y = "OK";

            ReferneceClass c5 = new ReferneceClass();
            c5 = c1;
            c5.X = 2;

            ReferneceClass c6 = c1;

            Console.WriteLine(ReferenceEquals(c1, c2).ToString()); // False
            Console.WriteLine(ReferenceEquals(c1, c3).ToString()); // False
            Console.WriteLine(ReferenceEquals(c1, c4).ToString()); // False
            Console.WriteLine(ReferenceEquals(c1, c5).ToString()); // True
            Console.WriteLine(ReferenceEquals(c1, c6).ToString()); // True
            Console.WriteLine();
            Console.WriteLine(Equals(c1, c2).ToString()); // False
            Console.WriteLine(Equals(c1, c3).ToString()); // False
            Console.WriteLine(Equals(c1, c4).ToString()); // False
            Console.WriteLine(Equals(c1, c5).ToString()); // True
            Console.WriteLine(Equals(c1, c6).ToString()); // True
            Console.WriteLine();
            Console.WriteLine(c1.Equals(c2).ToString()); // False
            Console.WriteLine(c1.Equals(c3).ToString()); // False
            Console.WriteLine(c1.Equals(c4).ToString()); // False
            Console.WriteLine(c1.Equals(c5).ToString()); // True
            Console.WriteLine(c1.Equals(c6).ToString()); // True
            Console.WriteLine();
            Console.WriteLine(c1 == c2); // False
            Console.WriteLine(c1 == c3); // False
            Console.WriteLine(c1 == c4); // False
            Console.WriteLine(c1 == c5); // True
            Console.WriteLine(c1 == c6); // True
            Console.WriteLine();
            Console.ReadLine();
        }
    }

    public class ReferneceClass
    {
        public int X
        {
            get;
            set;
        }

        public string Y
        {
            get;
            set;
        }

        public struct ValueStruce
        {
            public int x;
            public string y;
        }
    }
}

c1,c2,c3,c4为不同的实例，c1,c5,c6是同一个引用

using System;

namespace ConsoleApplication14
{
    class Program
    {
        static void Main(string[] args)
        {
            ValueStruce c1 = new ValueStruce();
            c1.x = 1;
            c1.y = "OK";

            ValueStruce c2 = new ValueStruce();
            c2.x = 1;
            c2.y = "OK";

            ValueStruce c3 = new ValueStruce();
            c3.x = 1;
            c3.y = "OK!";

            ValueStruce c4 = new ValueStruce();
            c4.x = 2;
            c4.y = "OK";

            ValueStruce c5 = new ValueStruce();
            c5 = c1;
            c5.x = 2;

            ValueStruce c6 = c1;

            Console.WriteLine(ReferenceEquals(c1, c2).ToString()); // False
            Console.WriteLine(ReferenceEquals(c1, c3).ToString()); // False
            Console.WriteLine(ReferenceEquals(c1, c4).ToString()); // False
            Console.WriteLine(ReferenceEquals(c1, c5).ToString()); // False
            Console.WriteLine(ReferenceEquals(c1, c6).ToString()); // False
            Console.WriteLine();
            Console.WriteLine(Equals(c1, c2).ToString()); // True
            Console.WriteLine(Equals(c1, c3).ToString()); // False
            Console.WriteLine(Equals(c1, c4).ToString()); // False
            Console.WriteLine(Equals(c1, c5).ToString()); // False
            Console.WriteLine(Equals(c1, c6).ToString()); // True
            Console.WriteLine();
            Console.WriteLine(c1.Equals(c2).ToString()); // True
            Console.WriteLine(c1.Equals(c3).ToString()); // False
            Console.WriteLine(c1.Equals(c4).ToString()); // False
            Console.WriteLine(c1.Equals(c5).ToString()); // False
            Console.WriteLine(c1.Equals(c6).ToString()); // True
            
            Console.ReadLine();
        }
    }

    public class ReferneceClass
    {
        public int X
        {
            get;
            set;
        }

        public string Y
        {
            get;
            set;
        }
    }

    public struct ValueStruce
    {
        public int x;
        public string y;
    }
}

• 静态ReferenceEquals，从方法名也可以看出比较的是引用地址，在堆值类型进行比较的时候，始终为false，即使是ReferenceEquals(1,1)，因为这里它这里把值先装箱再进行比较，所以两个引用地址是不一样的，但是ReferenceEquals(null,null)的值是True。
• 静态方法Equals(object objA, object objB) 这个方法其实最终调用了虚拟Equals方法的不同重载。
• 虚拟Equals方法，可在不同类中重载，比如String.Equals方法就是用于判断两个字符串的内容是否相等。一般来说，对于值类型，类型相同，并且数值相同（对于Struct的每个成员都必须相同），则Equals返回True，否则返回False。而对于引用类型，默认的行为与ReferenceEquals的行为相同，仅有两个对象指向同一个Reference的时候才返回True。静态Equals相比虚拟Equals方法有一个优点，就在于它不用考虑比较的对象是否为null。
• ==运算符，对于内置的值类型，直接判断两个对象的值是否相等，并会根据需要对对象进行类型转换，对于用户定义的值类型，比如Struct，不可使用；对于引用类型，默认的行为与ReferenceEquals的行为相同，但是很多类对==进行了重载，比如String。

using System;

namespace ConsoleApplication12
{
    class Program
    {
        static void Main(string[] args)
        {
            string a = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
            string b = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
            Console.WriteLine(a == b);
            Console.WriteLine(a.Equals(b));

            object g = a;
            object h = b;
            Console.WriteLine(g == h);
            Console.WriteLine(g.Equals(h));

            Person p1 = new Person("jia");
            Person p2 = new Person("jia");
            Console.WriteLine(p1 == p2);
            Console.WriteLine(p1.Equals(p2));

            Person p3 = new Person("jia");
            Person p4 = p3;
            Console.WriteLine(p3 == p4);
            Console.WriteLine(p3.Equals(p4));

            Console.ReadLine();

        }
    }

    class Person
    {
        private string name;

        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }

        public Person(string name)
        {
            this.name = name;
        }
    }
}

运行结果：