相等性 比较【ReferenceEquals、静态Equals、==(ceq）、实例eEquals】

感觉 最近学习学疯了，突然对以前熟悉的东西感到陌生。然后又回头重新挖掘一下

什么是相等性呢？以前一直用== 默认是值相等，从未去考虑，是地址相等还值相等。今天就详细的研究一下。

.net 平台提供了4中相等性比较符。ReferenceEquals、静态Equals、实例eEquals、==(“ceq”MSIL 命令 )

ceq的意思是compare for equality。针对原始类型，C#的==操作符并没有使用.NET里提供的那些Equals方法，这时==操作符使用专用的汇编语言指令来进行判断相等性的。

比较的效率：ReferenceEquals>

.net 提供了4种等比较方法 3个是object方法可继承， 【ceq】MSIL 操作符，可以重载	【object方法】			【ceq】MSIL 操作符
	ReferenceEquals	实例eEquals	静态Equals	==
object	引用地址	值,  A.Equals.(B)要求实例A不能是null，B实例可以是null,值类型比的是值，引用类型比的是地址	值 object.Equals.(A，B)2个实例都可以是null。值类型比的是值，引用类型比的是地址	引用地址
string	继承object，注意拘留池 不可变变对引用地址的隐形	值：5重载'==	继承object	值：重载'==
Tuple	继承object	值：重载	继承object	引用地址
Delegate	继承object	重载 若两个运行时间类型相同的委托操作数均为 null 比较委托列表地址和排序:	继承object	若两个运行时间类型相同的委托操作数均为 null 比较委托列表地址和排序:重载
接口	继承object	继承object	继承object	引用地址
自定义class	继承object	继承object	继承object	引用地址
泛型	继承object	引用地址	继承object	限制为 Where T:class 才能在内部使用 引用地址 因为传入也有可能是struct类型，不能用==
记录类型	继承object	值： 当两个记录操作数均为 null 或所有字段的对应值和自动实现的属性相等时，两个记录操作数都相等对于记录,编译器将生成 Equals 方法	继承object	值：重载'== 当两个记录操作数均为 null 或所有字段的对应值和自动实现的属性相等时，两个记录操作数都相等
内置值类型:struct	继承object不要用，因为装箱会导致引用地址不一样。	值：重载	继承object	值
自定义 ValueTuple:struct	继承object不要用，因为装箱会导致引用地址不一样。	值：ValueType重载了Object的Equals()方法。当比较两个值类型变量是否相等时，可以调用继承自ValueType类型的Equals()方法。这个重载的方法内部使用了反射，获得值类型所有的字段，然后进行比较。 对于值类型，应始终重写 Equals ，因为依赖于反射的相等性测试会降低性能。	继承object	值类型默认无法使用 == 操作符，除非对它进行重写
Enum:class	继承object不要用，因为装箱会导致引用地址不一样。	值：重载	继承object	值
Tuple	静态类Tuple
struct	抽象类ValueType	抽象类的映射，是不能使用抽象类的所有成员，只能用来继承
enum	抽象类Enum	抽象类的映射，是不能使用抽象类的所有成员，只能用来继承
delegate	抽象类 MulticastDelegate	抽象类的映射，是不能使用抽象类的所有成员，只能用来继承
string	密封类String	重载==
long	只读结构体Int64
ulong	只读结构体UInt64
int	只读结构体Int32
uint	只读结构体UInt32
short	只读结构体Int16
ushort	只读结构体UInt16
byte	只读结构体Byte
sbyte	只读结构体Sbyte
nint	只读结构体IntPtr
nuint	只读结构体UIntPtr
float	只读结构体Single	重载==
double	只读结构体Double	重载==
decimal	只读结构体Decimal	重载==
char	只读结构体Char
bool	只读结构体Boolean
ValueTuple	结构体ValueTuple
可空类型	静态类Nullable

object相等性 比较

对这4方法的研究我们从object开始。

object 并未重载==，所以在object使用==相等的比较中，object是对堆栈的中引用地址进行比较。

【ReferenceEquals】是引用类型的引用地址相等比较，只能在引用类型比较使用。值类型因为会涉及到装箱后地址会不相同，所以对比的结果都是fase；

[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
    [System.Runtime.Versioning.NonVersionable]
    public static bool ReferenceEquals (Object objA, Object objB) {
        return objA == objB;
    }

【静态Equals】对值进行比较

public static void Equals( object left, object right )
{
//这一步是是引用类型比较。值类型装箱后地址不一样需要进一步判断
    if( left == right )
        return true;//引用类型比较之间对比堆栈中的引用地址，
    // both null references handled above
    if( ( left == null ) || ( right == null ) )
        return false;
    return left.Equals( right );//这一步是判断值类型的,最终也是引用RuntimeHelpers.Equals

}

【==】在object中没有重载==，object在堆栈保存的是引用地址，所以它进行直接引用比较。

  int i = 1,j = 1;
 Console.WriteLine( (object)i==(object)j);//false，int装箱后的地址是不一样的

【实例Equals】 是比较值相等。

   public virtual bool Equals(Object obj)
    {
        return RuntimeHelpers.Equals(this, obj);
    }

我们通过object的源代码就可以知道他们之间的差别了。

在object 中==和ReferenceEquals功能是一样的都是 比较地址是否相等。【静态Equals】判断的是值或者引用地址相等就相等。【实例Equals】判断的是值相等。

因此我在自定义 值类型时候要重载==，把他重载成值比较；在自定义引用类型的时候要重载Equals，把他重载成地址比较。

【== 】在值类型中表示值相等比较，在引用类型中表示引用地址相等比较，

【== 】在值类型的应用： 如果内置值类型的值相等，则其操作数相等：用户定义的 struct 值类型默认情况下不支持 == 运算符。 要支持 == 运算符，用户定义的结构必须重载它。重载是【！=】也要一起重载了。

【== 】 在引用类型的应用：默认情况下，如果两个非记录引用类型操作符引用同一对象，则这两个操作符相等：

默认情况下，用户定义的引用类型支持 == 运算符。 但是，引用类型可重载 == 运算符。 如果引用类型重载 == 运算符，使用 Object.ReferenceEquals 方法来检查该类型的两个引用是否引用同一对象。

记录类型相等性:在 C# 9.0 和更高版本中提供，记录类型支持 == 和 != 运算符，这些运算符默认提供值相等性语义。 也就是说，当两个记录操作数均为 null 或所有字段的对应值和自动实现的属性相等时，两个记录操作数都相等。

委托相等性:1、如果两个委托实例中有一个为 null，则当且仅当它们都为 null 时相等。

2、 具有不同运行时类型的委托永远不相等。
                                                       3、如果两个委托实例都具有调用列表，则当且仅当它们的调用列表长度相同，并且一个实例的调用列表中的每项依次等于（如下面的定义）另一个的调用列表中的相应项时，这两个委托实例相等。

     以下规则控制调用列表项的相等性：

如果两个调用列表项都引用同一静态方法，则这两项相等

如果两个调用列表项都引用同一个目标对象（引用相等运算符定义的目标对象）上的同一个非静态方法，则这两个调用列表项相等

（这句话不理解）    通过对语义相同的匿名_方法_表达式或具有相同（可能为空）捕获的外部变量实例集的lambda_表达式进行求值而生成的调用列表项允许（但不是必需）相等。

字符串的相等性比较：字符串string 具有值不变性和拘留池特性。字符串虽然是引用类型，但是相等比较时候（==、equal）是比较两个字符串的值，而不是对比引用地址是否相等。

在作字符串引用地址相等性比较时，要用Object.ReferenceEquals 方法。详细请看：

当 初始化字符串是常量时，运行时就会把常量保存在拘留池中，当遇到相同常量给string赋值时，clr就直接引用拘留池中的常量给string赋值。

     string a = "aasdsdsa";
      string b = "aasdsdsa";
       Console.WriteLine(object.ReferenceEquals(a, b)); //引用地址是相同的

 Equals和== 有什么区别？

Equals对于值类型装箱成object类型的比较时，是比较值，==是比较引用地址。

string 相等性 比较

string 重载了==操作符，把==操作符重载成 值相等

    public static bool operator ==(String a, String b)
            {
                return String.Equals(a, b);
            }

            public static bool Equals(String a, String b)
            {
                if ((Object)a == (Object)b)
                {
                    return true;
                }

                if ((Object)a == null || (Object)b == null)
                {
                    return false;
                }

                if (a.Length != b.Length)
                    return false;

                return EqualsHelper(a, b);
            }

stirng 重载了object的Equals方法, 将重载成应用值相等

public override bool Equals(Object obj) {
            if (this == null)                        //this is necessary to guard against reverse-pinvokes and
                throw new NullReferenceException();  //other callers who do not use the callvirt instruction

            String str = obj as String;
            if (str == null)
                return false;

            if (Object.ReferenceEquals(this, obj))
                return true;

            if (this.Length != str.Length)
                return false;

            return EqualsHelper(this, str);
        }

通过以上分析，string中Equals和==都对字符串值进行比较。所以在string中Equals和== 比较结果是一样的

【ReferenceEquals】在string使用这个函数，要注意string 拘留池的特性。运行时会把字符串常量捕获 存入拘留池。当用相同常量时，字符串拘留池就返回已经存在拘留池中字符串的地址。编译器会"x" + "y" + "z"进行运算得到“xyz”，由于拘留池中已经再次

“xyz”，所"x" + "y" + "z"就直接用字符串拘留池中的实例。

下运行结果是true

string s = "xyz";
Console.WriteLine(object.ReferenceEquals("x" + "y" + "z", s));

关语 C#中字符串优化String.Intern、IsInterned详解

值类型

非原始类型

看例子，这里有两个值类型：

当我使用==对它们进行比较的时候，直接报错了。

因为默认情况下，不可以使用==来对非原始类型的值类型进行相等性判断。要想使用==，就必须提供重载方法。

struct

当我们比较两个结构体是否相等时，怎么做呢？因为变量本身包含了结构体所有的字段(数据)，所以在比较时，就需要对两个结构体的字段进行逐个的一对一的比较，看看每个字段的值是否都相等，如果任何一个字段的值不等，就返回false。

==不可用，要重载后才可用

实际上，执行这样的一个比较并不需要我们自己编写代码，Microsoft已经为我们提供了实现的方法：所有的值类型继承自System.ValueType，ValueType和所有的类型都继承自System.Object，Object提供了一个Equals()方法，用来判断两个对象是否相等。但是ValueType覆盖了Object的Equals()方法。当我们比较两个值类型变量是否相等时，可以调用继承自ValueType类型的Equals()方法。这个复写的方法内部使用了反射，获得值类型所有的字段，然后进行比较。

     static void Main(string[] args)
            {
                Person per1 = new Person { name = "xiaolin", age = 12 };
                Person per2 = new Person { name = "xiaolin", age = 12 };

                Console.WriteLine(per1.Equals(per2));
                Console.WriteLine(Equals(per1, per2));

            }

  struct Person
        {
         public     int age;
        public    string name;

        }

Tuple

针对这两个tuple，我做了三个相等性判断，通过第一个ReferenceEquals方法我们可以知道这两个tuple变量指向不同的实例。

而tp1.Equals(tp2)返回的是True，这是因为Tuple类（引用类型）重写了object.Equals()方法，从而比较的是Tuple里面的值。

尽管微软为Tuple把object.Equals()方法重写了，但是它并没有处理==操作符，所以==还是在比较引用的相等性，所以会返回False。

这样做确实挺让人迷惑的。。。

泛型

另一种不适合使用==操作符的情景是涉及泛型的时候，直接看例子：

static bool ByEqualOperator<T>(T a,T b){

return a==b;
}

这个泛型方法直接报错了，因为==操作符无法应用于这两个操作数T，T可以是任何类型，例如T是非原始类型的struct，那么==就不可用。我们无法为泛型指定约束让其实现某个操作符。针对这个例子，我可以这样做，来保证可以编译：

现在T是引用类型了，代码可以编译了。我们使用以下该方法：

按理说这就相当于调用了Equals()方法，结果应该返回True。而实际结果是：false

之所以返回了False，是因为泛型方法里的==操作符比较的是引用，而这又是因为尽管编译器知道可以把==操作符应用于类型T，但是它仍然不知道具体是哪个类型T会重载该操作符，所以它会假设T不会重载==操作符，从而对待这两个操作数如同object类型一样并编译，所以判断的是引用相等性。

所以泛型方法不会选择任何的操作符重载，它对待泛型类就像对待object类型一样。

综上，针对泛型方法，应该使用Equals()方法，而不是==操作符。

备注：

ceq的意思是compare for equality，就是比较两个值是否相等，在运行时，它将会被转换为硬件上的比较，也许用的是CPU的寄存器