相等性、同一性 （Equals、ReferenceEquals、==区别）

using System;
using System.Collections.Generic;
using System.Text;

namespace AboutEquals
{
    //http://net.itcast.cn/ViewArticle-57.aspx

    #region 引用相等性，即同一性  （一）
    //class Test
    //{
    //    static void Main()
    //    {
    //        Test1 a = new Test1(1, "Hi");
    //        Test1 b = new Test1(1, "Hi");

    //        bool areEqual = System.Object.ReferenceEquals(a, b);//创建了两个对象

    //        System.Console.WriteLine("ReferenceEquals(a, b) = {0}", areEqual); //  False 引用内存中的不同基础对象

    //        b = a;//赋值

    //        areEqual = System.Object.ReferenceEquals(a, b);//引用内存中的相同基础对象

    //        System.Console.WriteLine("ReferenceEquals(a, b) = {0}", areEqual);//True

    //        System.Console.WriteLine("ReferenceEquals(1, 1) = {0}", System.Object.ReferenceEquals(1, 1));//False  每个变量都会被装箱到单独的对象实例中,因此值类型对象无法具有引用相等性

    //        Console.WriteLine("Press any key to exit.");
    //        Console.ReadKey();
    //    }

    //}
    //class Test1
    //{
    //    public int Num;
    //    public string Str;

    //    public Test1(int num, string str)
    //    {
    //        this.Num = num;
    //        this.Str = str;
    //    }
    //}
    #endregion

    #region 引用相等性，即同一性 以及  值相等性 （二）
    //struct TestStruct
    //{
    //    public int Num;// { get; private set; }
    //    public string Name;//{ get; private set; }

    //    public TestStruct(int i, string s)
    //        : this()
    //    {
    //        Num = i;
    //        Name = s;
    //    }
    //}

    //class TestClass
    //{
    //    public int Num;
    //    public string Name;
    //    public TestClass(int a, string b)
    //    {
    //        this.Num = a;
    //        this.Name = b;
    //    }
    //}

    //class Test
    //{
    //    static void Main()
    //    {
    //        #region ReferenceTypes  测试引用相等性

    //        TestClass tcA = new TestClass(1, "New TestClass");
    //        TestClass tcB = new TestClass(1, "New TestClass");

    //        Console.WriteLine("ReferenceEquals(tcA, tcB) = {0}", Object.ReferenceEquals(tcA, tcB)); // false

    //        tcB = tcA;
    //        Console.WriteLine("After asignment: ReferenceEquals(tcA, tcB) = {0}", Object.ReferenceEquals(tcA, tcB)); // true

    //        tcA.Num = 42;
    //        tcA.Name = "TestClass 42";
    //        Console.WriteLine("tcB.Name = {0} tcB.Num: {1}", tcB.Name, tcB.Num);// 42,"TestClass 42"
    //        #endregion

    //        #region ValueTypes  测试值相等性

    //        TestStruct tsC = new TestStruct(1, "TestStruct 1");

    //        // Value types are copied on assignment. tsD and tsC have the same values but are not the same object.
    //        // 值类型被复制，tsD与tsC有相同的值，但对象却不同  注：由于在将值类型的实例赋给变量时将建立值的副本，因此值类型对象无法具有引用相等性
    //        // 永远不能有引用内存中的同一位置的两个未装箱结构，因为每个变量都会被装箱到单独的对象实例中
    //        TestStruct tsD = tsC;
    //        Console.WriteLine("After asignment: ReferenceEquals(tsC, tsD) = {0}", Object.ReferenceEquals(tsC, tsD)); // false
    //        #endregion

    //        #region stringRefEquality
    //        //对于String类，默认的相同的字符串在堆上只保留一个Copy，所以strA与strB指向同一地址
    //        string strA = "Hello world!";
    //        string strB = "Hello world!";
    //        Console.WriteLine("ReferenceEquals(strA, strB) = {0}", Object.ReferenceEquals(strA, strB)); // true

    //        //字符串不再相同，不再指向同一地址
    //        //当我们改变string值的时候，便会在托管堆上重新分配一块新的内存空间，而不会影响到原有的内存地址上所存储的值。
    //        strA = "Goodbye world!";
    //        Console.WriteLine("strA = /"{0}/" strB = /"{1}/"", strA, strB);
    //        Console.WriteLine("After strA changes, ReferenceEquals(strA, strB) = {0}", Object.ReferenceEquals(strA, strB)); // false

    //        // 动态生成的字符串,这样的字符串是不会添加到缓存哈希表中进行维护的
    //        StringBuilder sb = new StringBuilder("Hello world!");
    //        string stringC = sb.ToString();

    //        /*在CLR被加载之后，便SystemDomain所对应的托管堆中初始化了一个HashTable。这个HashTable的目的就是为了存储我们所创建过的字符串。
    //          在Hashtable中，Key是string的内容，Value是这个字符串所对应的内存地址
    //          当初始化一个字符串时，会首先在这个系统初始化的HashTable中查找每一个字符串常量在HashTable中是否存在，不存在它将分配一块内存地址来存储这个字符串常量，然后在HashTable中
    //          增加一个键值对，将字符串的内容存为key,而将分配的内存地址存为Value
    //         */

    //        // False  此时的stringC是动态生成的字符串,这样的字符串是不会添加到缓存哈希表中进行维护的
    //        Console.WriteLine("ReferenceEquals(stringC, strB) = {0}", Object.ReferenceEquals(stringC, strB));

 

    //        //我们可以使用Intern搜索整个Hashtable,找是否有这个字符串的相关引用，如果找到了它便会将这个引用返回给stringC
    //        Console.WriteLine("ReferenceEquals(stringC, strB) = {0}", Object.ReferenceEquals(String.Intern(stringC), strB));//true

    //        // The string class overloads the == operator to perform an equality comparison.
    //        Console.WriteLine("stringC == strB = {0}", stringC == strB); // true

    //        #endregion

    //        // Keep the console open in debug mode.
    //        Console.WriteLine("Press any key to exit.");
    //        Console.ReadKey();
    //    }
    //}

    #endregion

    #region Equals,==,ReferenceEquals区别
    class Test
    {
        public static void Main(string[] args)
        {
            //string a = "Hello World";
            //string b = "Hello World";
            //StringBuilder sb = new StringBuilder("Hello world!");
            //string c = sb.ToString();
            //Console.WriteLine(Object.Equals(a, b));
            //Console.WriteLine(Object.Equals(a, c));

            ////TestStruct tsC = new TestStruct(1, "TestStruct 1");
            ////TestStruct tsD = tsC;
            ////Console.WriteLine("After asignment: Equals(tsC, tsD) = {0}", Object.Equals(tsC, tsD));

            //Console.WriteLine("After asignment: ReferenceEquals(a, b) = {0}", Object.ReferenceEquals(a, "Hello " + "World"));
            //Console.WriteLine("After asignment: Equals(a, b) = {0}", Object.Equals(a, "Hello " + "World"));

 

            //string peom1 = "Kubla Khan";
            //string peom2 = "Kubla Khan";
            //string peom3 = String.Copy(peom2);
            //string peom4 = "kubla khan";

            ////ReferenceEquals()判断两个字符串是否指向相同的内存地址  
            //Console.WriteLine("peom1 == peom2:" + (peom1 == peom2));//True  
            //Console.WriteLine("peom1 == peom3:" + (peom1 == peom3));//True  
            //Console.WriteLine("ReferenceEquals(peom1,peom3):" + ReferenceEquals(peom1, peom3));//False  

            ////Equals,先判断两个字符串有相同的内存位置，则两个字符串相等；否则逐字符比较两个字符串，判断是否相等  
            //Console.WriteLine("Equal(peom1,peom3):" + String.Equals(peom1, peom2));//true  
            //Console.WriteLine("Equal(peom1,peom3):" + String.Equals(peom1, peom3));//true

            //ReferenceEquals已知   用于引用类型

            /*" ==  "
             *
             * 用于引用类型与值类型：
             *
             * 对于内置的值类型，它判断的是两个对象的值是否相等，它会根据需要进行必要的类型转换，并根据两个对象的值是否相等判断是true还是false
             *
             * 对于用户定义的值类型，如果没有重载操作符==，==将不能使用
             *
             * 对于引用类型，== 默认的行为与ReferenceEquals的行为相同，仅有两个对象指向同一个Reference的时候才返回true。但是.NET Framework中的
             * 类很多对==进行了重载，例如String类的==与Equals的行为相同，判断两个字符串的内容是否相等。所以在应用中，对于系统定义的引用类型建议
             * 不要使用==操作符，以免程序出现与预期不同的运行结果。
             *
             *
             * 引用类型最好不要重载定义==操作符
             *
             * http://blog.youkuaiyun.com/wuchen_net/archive/2010/03/23/5409327.aspx
             *
             * 重载形式：
             * public static bool operator == ( KeyData left,  KeyData right );
             * public struct  KeyData
             * {
             *      public int data;
             *      public int Data
             *      {
             *          set
             *          {
             *              data = value;
             *          }
             *          get
             *          {
             *              return  data ;
             *          }
             *      }
             *      public static bool  operator ==(KeyData left,KeyData right)
             *      {
             *          return  left.data==right.data;
             *      }
             *      public static bool  operator !=(KeyData left,KeyData right)
             *      {
             *          return  left.data!=right.data;
             *      }
             * }
             *
             * 由于==操作与!=操作要同步定义，所以在定义==重载函数的时候，也要定义!=重载函数。这也是.Net在判等操作保持一致性。那么对于最后一个
             * 判等函数，这种重载运算符的方法并不适合引用类型。这就是.Net经常现象，去判断两个引用类型，不要用==，而要用某个对象的Equals函数。
             * 所以在编写自己类型的时候，要保留这种风格。
             *
             */

            //测试值类型：
            //int a = 3;
            //double b = 3.0;
            //Console.WriteLine(a == b);//true

 

 

            /*"Equals"
             *
             * 用于引用类型与值类型：
             *
             * Equals方法对于值类型和引用类型的定义不同，对于值类型，类型相同，并且数值相同(对于struct的每个成员都必须相同)，则Equals返回 true,
             * 否则返回false。而对于引用类型，默认的行为与ReferenceEquals的行为相同，仅有两个对象指向同一个Reference的时 候才返回true。可以根据
             * 需要对Equals进行重载，例如String类的Equals用于判断两个字符串的内容是否相等。
             *
             *
             * 静态的Equals()方法：
             *
             * Equals()的静态版本与其虚拟实例版本的作用相同，其区别是静态版本带有两个参数，并对它们进行相等比较。这个方法可以处理两个对象中有一
             * 个是null的情况，因此，如果一个对象可能是null，这个方法就可以抛出异常，提供了额外的保护。静态重载版本首先要检查它传送的引用是否为
             * null。如果它们都是null，就返回true(因为null与null相等)。如果只有一个引用是null，就返回false。如果两个引用都指向某个对象，它就调用
             * Equals()的虚拟实例版本。这表示在重写Equals()的实例版本时，其效果相当于也重写了静态版本。以下是其执行步骤,一共三个步骤：
             *
             * public static bool Equals( object left, object right );
             * 按照书中对它的分析，其大致函数代码如下：
             * public static void Equals( object left, object right )
             * {
             *      第一步是需要根据对象所属类型的==操作符的执行结果
             *      if(left==right)
             *      {
             *          return true;
             *      }
             *      第二步是判别是否为null
             *      if(left==null&&right==null)
             *      {
             *          return true;
             *      }
             *      最后一步要使用到虚拟的Equals函数的执行结果
             *      return left.Equals(right);
             *     
             * }
             *
             * 虚拟的Equals()方法：
             *
             * Equals()虚拟版本的System.Object实现代码也比较引用。但因为这个方法是虚拟的，所以可以在自己的类中重写它，按值来比较对象。特别是如果
             * 希望类的实例用作字典中的键，就需要重写这个方法，以比较值。否则，根据重写Object.GetHashCode()的方式，包含对象的字典类要么不工作，要
             * 么工作的效率非常低。在重写Equals()方法时要注意，重写的代码不会抛出异常。这是因为如果抛出异常，字典类就会出问题，一些在内部调用这个
             * 方法的.NET基类也可能出问题。以下是一个Equals方法重写的例子：
             *
             * public override bool Equals(object right)
             * {
             *      if(right==null)
             *      {
             *          return false;
             *      }
             *      if(object.ReferenceEquals(this,right))
             *      {
             *          return true;
             *      }
             *      该方法是重写新增的
             *      if(right.GetType()==this.GetType())
             *      {
             *          return true;
             *      }
             * }//详细见http://www.cnblogs.com/happygoodluck/archive/2010/08/08/1795007.html
             *
             * 除此外对于类型的Equals函数来，其实并没有限制类型非要属于引用类型，对于值类型也是可以重载此函数，但是我并不推荐，主要是Equals函数的
             * 参数类型是不可变的，也就是说通过此方法，值类型要经过装箱操作，而这是比较影响效率的。
             *
             *
             *
             *
             *
             *
             *
             *
             */

            int n = 10;
            double t = n;
           
            Console.WriteLine(Object.Equals(10.0, t));

            Console.ReadKey();

        }

    }

    #endregion
}