C＃.Equals（）、. ReferenceEquals（）和==运算符

Question

我对这三个方面的理解是：

• .Equals()测试数据是否相等（缺少更好的描述）。 .Equals()可以为同一对象的不同实例返回True，这是最常用的方法。

• .ReferenceEquals()测试两个对象是否是同一实例，并且不能被覆盖。

• 默认情况下， ==与ReferenceEquals()相同，但是可以覆盖此值。

但是C＃站指出：

在对象类中， Equals和ReferenceEquals方法在语义上等效，不同之处在于ReferenceEquals仅适用于对象实例。 ReferenceEquals方法是静态的。

现在我不明白。 谁能对此有所启发？

Answer 1

造成混淆的原因似乎是C＃站的摘录中有一个错字，该错字应为：“ ...，但Equals仅适用于对象实例。ReferenceEquals方法是静态的。”

---

您对每个语义含义的差异大体上是正确的（尽管“同一对象的不同实例”似乎有些混乱，但它可能应该读为“同一类型的不同实例”），并且可以对其进行覆盖。

如果我们将其放在一边，让我们处理您的问题的最后一部分，即它们如何与普通的System.Object实例和System.Object引用一起工作（我们都需要规避==的非多态性质）。 在这里，所有这三个操作将等效地工作，但有一个警告：不能在null上调用Equals 。

Equals是一个采用一个参数（ 可以为null ）的实例方法。 由于它是一个实例方法（必须在实际对象上调用），因此不能在null引用上调用。

ReferenceEquals是一个带有两个参数的静态方法，其中两个参数都可以为null 。 由于它是静态的（不与对象实例相关联），因此在任何情况下都不会引发NullReferenceException 。

==是一个运算符，在这种情况下（ object ）的行为与ReferenceEquals相同。 它也不会抛出NullReferenceException 。

为了显示：

object o1 = null;
object o2 = new object();

//Technically, these should read object.ReferenceEquals for clarity, but this is redundant.
ReferenceEquals(o1, o1); //true
ReferenceEquals(o1, o2); //false
ReferenceEquals(o2, o1); //false
ReferenceEquals(o2, o2); //true

o1.Equals(o1); //NullReferenceException
o1.Equals(o2); //NullReferenceException
o2.Equals(o1); //false
o2.Equals(o2); //true

Answer 2

看一下有关该主题的这篇MSDN文章 。

我认为有关的要点是：

要检查引用是否相等，请使用ReferenceEquals。 要检查值是否相等，请使用“等于”或“等于”。

默认情况下，operator ==通过确定两个引用是否指示同一对象来测试引用是否相等，因此引用类型不需要实现operator ==即可获得此功能。 当类型是不可变的时，意味着实例中包含的数据无法更改，重载运算符==以比较值相等而不是引用相等是很有用的，因为作为不可变对象，只要它们具有相同的值。

希望这可以帮助！

Answer 3

您对.ReferenceEquals的理解是正确的。

.Equals检查值类型的数据相等性，非值类型（通用对象）的引用相等性。

可以覆盖等于以使对象执行某种形式的数据相等性检查

编辑：此外，.ReferenceEquals不能用于值类型（可以，但是始终为false）

Answer 4

想要加上与“ null”比较的5美分。

1. ReferenceEquals （对象，对象）与“（object）arg1 == arg2”相同（因此，在使用值类型的情况下，需要装箱并花费时间）。 但是这种方法是在几种情况下检查参数是否为null的唯一100％安全的方法，例如

   • a）在通过调用其成员之前。 算子
   • b）检查AS运算符的结果。

2. ==和Equals（） 。 为什么我要说ReferenceEquals使用null检查是100％安全的？ 想象一下，您在核心的跨项目库中编写了通用扩展，并说您将通用参数类型限制为某些域类型。 这种类型可以引入“ ==”运算符-现在或以后（相信我，我已经看到很多，这种运算符可以具有非常“奇怪的”逻辑，尤其是在涉及域或持久性对象时）。 您尝试检查参数是否为null，然后对其调用成员操作。 惊喜，您可以在此处使用NullRef。 因为==运算符几乎与Equals（）相同-非常自定义且非常不可预测。 但是有一个区别，应该加以考虑-如果您不将通用参数限制为某些自定义类型（==仅在您的类型为“类”时才可以使用），==运算符与object相同.ReferenceEquals（..）。 等于实现始终是从最终类型使用的，因为它是虚拟的。

因此，我的建议是，当您编写自己的类型或从知名类型派生时，可以使用==检查null。 否则，请使用object.ReferenceEquals（arg，null）。

Answer 5

在Object类中，.quals实现标识，而不是相等。 它检查引用是否相等。 代码可能像这样：

public virtual Boolean Equals(Object other) {
    if (this == other) return true;
    return false;
}

在类中实现.Equals时，仅当基类不是Object时，才应调用基类.Equals。 是的，那很复杂。

甚至更多，因为派生类可以覆盖.Equals，因此您不能调用它来检查身份Microsoft添加了静态.ReferenceEquals方法。

如果您使用某个类，那么从逻辑上讲，.Equals检查是否相等，.ReferenceEquals检查身份。

Answer 6

我已经扩展了Ani的出色答案，以显示在处理引用类型和重写的相等方法时的主要区别。

• 您可以在此处查看此代码的有效版本： https : //dotnetfiddle.net/dFKMhB
• 或者，将此代码粘贴到LinqPad并作为Language: C# Program 。

。

void Main()
{

    //odd os are null; evens are not null
    object o1 = null;
    object o2 = new object();
    object o3 = null;
    object o4 = new object();
    object o5 = o1;
    object o6 = o2;

    Demo d1 = new Demo(Guid.Empty);
    Demo d2 = new Demo(Guid.NewGuid());
    Demo d3 = new Demo(Guid.Empty);

    Debug.WriteLine("comparing null with null always yields true...");
    ShowResult("ReferenceEquals(o1, o1)", () => ReferenceEquals(o1, o1)); //true
    ShowResult("ReferenceEquals(o3, o1)", () => ReferenceEquals(o3, o1)); //true
    ShowResult("ReferenceEquals(o5, o1)", () => ReferenceEquals(o5, o1)); //true 
    ShowResult("o1 == o1", () => o1 == o1); //true
    ShowResult("o3 == o1", () => o3 == o1); //true
    ShowResult("o5 == o1", () => o5 == o1); //true 

    Debug.WriteLine("...though because the object's null, we can't call methods on the object (i.e. we'd get a null reference exception).");
    ShowResult("o1.Equals(o1)", () => o1.Equals(o1)); //NullReferenceException
    ShowResult("o1.Equals(o2)", () => o1.Equals(o2)); //NullReferenceException
    ShowResult("o3.Equals(o1)", () => o3.Equals(o1)); //NullReferenceException
    ShowResult("o3.Equals(o2)", () => o3.Equals(o2)); //NullReferenceException
    ShowResult("o5.Equals(o1)", () => o5.Equals(o1));  //NullReferenceException
    ShowResult("o5.Equals(o2)", () => o5.Equals(o1));  //NullReferenceException

    Debug.WriteLine("Comparing a null object with a non null object always yeilds false");
    ShowResult("ReferenceEquals(o1, o2)", () => ReferenceEquals(o1, o2)); //false
    ShowResult("ReferenceEquals(o2, o1)", () => ReferenceEquals(o2, o1)); //false
    ShowResult("ReferenceEquals(o3, o2)", () => ReferenceEquals(o3, o2)); //false
    ShowResult("ReferenceEquals(o4, o1)", () => ReferenceEquals(o4, o1)); //false
    ShowResult("ReferenceEquals(o5, o2)", () => ReferenceEquals(o3, o2)); //false
    ShowResult("ReferenceEquals(o6, o1)", () => ReferenceEquals(o4, o1)); //false
    ShowResult("o1 == o2)", () => o1 == o2); //false
    ShowResult("o2 == o1)", () => o2 == o1); //false
    ShowResult("o3 == o2)", () => o3 == o2); //false
    ShowResult("o4 == o1)", () => o4 == o1); //false
    ShowResult("o5 == o2)", () => o3 == o2); //false
    ShowResult("o6 == o1)", () => o4 == o1); //false
    ShowResult("o2.Equals(o1)", () => o2.Equals(o1)); //false
    ShowResult("o4.Equals(o1)", () => o4.Equals(o1)); //false
    ShowResult("o6.Equals(o1)", () => o4.Equals(o1)); //false

    Debug.WriteLine("(though again, we can't call methods on a null object:");
    ShowResult("o1.Equals(o2)", () => o1.Equals(o2)); //NullReferenceException
    ShowResult("o1.Equals(o4)", () => o1.Equals(o4)); //NullReferenceException
    ShowResult("o1.Equals(o6)", () => o1.Equals(o6)); //NullReferenceException

    Debug.WriteLine("Comparing 2 references to the same object always yields true");
    ShowResult("ReferenceEquals(o2, o2)", () => ReferenceEquals(o2, o2)); //true    
    ShowResult("ReferenceEquals(o6, o2)", () => ReferenceEquals(o6, o2)); //true <-- Interesting
    ShowResult("o2 == o2", () => o2 == o2); //true  
    ShowResult("o6 == o2", () => o6 == o2); //true <-- Interesting
    ShowResult("o2.Equals(o2)", () => o2.Equals(o2)); //true 
    ShowResult("o6.Equals(o2)", () => o6.Equals(o2)); //true <-- Interesting

    Debug.WriteLine("However, comparing 2 objects may yield false even if those objects have the same values, if those objects reside in different address spaces (i.e. they're references to different objects, even if the values are similar)");
    Debug.WriteLine("NB: This is an important difference between Reference Types and Value Types.");
    ShowResult("ReferenceEquals(o4, o2)", () => ReferenceEquals(o4, o2)); //false <-- Interesting
    ShowResult("o4 == o2", () => o4 == o2); //false <-- Interesting
    ShowResult("o4.Equals(o2)", () => o4.Equals(o2)); //false <-- Interesting

    Debug.WriteLine("We can override the object's equality operator though, in which case we define what's considered equal");
    Debug.WriteLine("e.g. these objects have different ids, so we treat as not equal");
    ShowResult("ReferenceEquals(d1,d2)",()=>ReferenceEquals(d1,d2)); //false
    ShowResult("ReferenceEquals(d2,d1)",()=>ReferenceEquals(d2,d1)); //false
    ShowResult("d1 == d2",()=>d1 == d2); //false
    ShowResult("d2 == d1",()=>d2 == d1); //false
    ShowResult("d1.Equals(d2)",()=>d1.Equals(d2)); //false
    ShowResult("d2.Equals(d1)",()=>d2.Equals(d1)); //false
    Debug.WriteLine("...whilst these are different objects with the same id; so we treat as equal when using the overridden Equals method...");
    ShowResult("d1.Equals(d3)",()=>d1.Equals(d3)); //true <-- Interesting (sort of; different to what we saw in comparing o2 with o6; but is just running the code we wrote as we'd expect)
    ShowResult("d3.Equals(d1)",()=>d3.Equals(d1)); //true <-- Interesting (sort of; different to what we saw in comparing o2 with o6; but is just running the code we wrote as we'd expect)
    Debug.WriteLine("...but as different when using the other equality tests.");
    ShowResult("ReferenceEquals(d1,d3)",()=>ReferenceEquals(d1,d3)); //false <-- Interesting (sort of; same result we had comparing o2 with o6; but shows that ReferenceEquals does not use the overridden Equals method)
    ShowResult("ReferenceEquals(d3,d1)",()=>ReferenceEquals(d3,d1)); //false <-- Interesting (sort of; same result we had comparing o2 with o6; but shows that ReferenceEquals does not use the overridden Equals method)
    ShowResult("d1 == d3",()=>d1 == d3); //false <-- Interesting (sort of; same result we had comparing o2 with o6; but shows that ReferenceEquals does not use the overridden Equals method)
    ShowResult("d3 == d1",()=>d3 == d1); //false <-- Interesting (sort of; same result we had comparing o2 with o6; but shows that ReferenceEquals does not use the overridden Equals method)


    Debug.WriteLine("For completeness, here's an example of overriding the == operator (wihtout overriding the Equals method; though in reality if overriding == you'd probably want to override Equals too).");
    Demo2 d2a = new Demo2(Guid.Empty);
    Demo2 d2b = new Demo2(Guid.NewGuid());
    Demo2 d2c = new Demo2(Guid.Empty);
    ShowResult("d2a == d2a", () => d2a == d2a); //true
    ShowResult("d2b == d2a", () => d2b == d2a); //false
    ShowResult("d2c == d2a", () => d2c == d2a); //true <-- interesting
    ShowResult("d2a != d2a", () => d2a != d2a); //false
    ShowResult("d2b != d2a", () => d2b != d2a); //true
    ShowResult("d2c != d2a", () => d2c != d2a); //false <-- interesting
    ShowResult("ReferenceEquals(d2a,d2a)", () => ReferenceEquals(d2a, d2a)); //true
    ShowResult("ReferenceEquals(d2b,d2a)", () => ReferenceEquals(d2b, d2a)); //false
    ShowResult("ReferenceEquals(d2c,d2a)", () => ReferenceEquals(d2c, d2a)); //false <-- interesting
    ShowResult("d2a.Equals(d2a)", () => d2a.Equals(d2a)); //true
    ShowResult("d2b.Equals(d2a)", () => d2b.Equals(d2a)); //false
    ShowResult("d2c.Equals(d2a)", () => d2c.Equals(d2a)); //false <-- interesting   

}



//this code's just used to help show the output in a friendly manner
public delegate bool Statement();
void ShowResult(string statementText, Statement statement)
{
    try 
    {
        Debug.WriteLine("\t{0} => {1}",statementText, statement());
    }
    catch(Exception e)
    {
        Debug.WriteLine("\t{0} => throws {1}",statementText, e.GetType());
    }
}

class Demo
{
    Guid id;
    public Demo(Guid id) { this.id = id; }
    public override bool Equals(object obj)
    {
        return Equals(obj as Demo); //if objects are of non-comparable types, obj will be converted to null
    }
    public bool Equals(Demo obj)
    {
        if (obj == null)
        {
            return false;
        }
        else
        {
            return id.Equals(obj.id);
        }
    }
    //if two objects are Equal their hashcodes must be equal
    //however, if two objects hash codes are equal it is not necessarily true that the objects are equal
    //i.e. equal objects are a subset of equal hashcodes
    //more info here: https://stackoverflow.com/a/371348/361842
    public override int GetHashCode()
    {
        return id.GetHashCode();
    }
}

class Demo2
{
    Guid id;
    public Demo2(Guid id)
    {
        this.id = id;
    }

    public static bool operator ==(Demo2 obj1, Demo2 obj2)
    {
        if (ReferenceEquals(null, obj1)) 
        {
            return ReferenceEquals(null, obj2); //true if both are null; false if only obj1 is null
        }
        else
        {
            if(ReferenceEquals(null, obj2)) 
            {
                return false; //obj1 is not null, obj2 is; therefore false
            }
            else
            {
                return obj1.id == obj2.id; //return true if IDs are the same; else return false
            }
        }
    }

    // NB: We also HAVE to override this as below if overriding the == operator; this is enforced by the compiler.  However, oddly we could choose to override it different to the below; but typically that would be a bad idea...
    public static bool operator !=(Demo2 obj1, Demo2 obj2)
    {
        return !(obj1 == obj2);
    }
}

Answer 7

Equals()根据基础类型（值/引用Equals()检查哈希码或等效项， ReferenceEquals()旨在始终检查哈希码。 如果两个对象都指向相同的内存位置，则ReferenceEquals返回true 。

double e = 1.5;
double d = e;
object o1 = d;
object o2 = d;

Console.WriteLine(o1.Equals(o2)); // True
Console.WriteLine(Object.Equals(o1, o2)); // True
Console.WriteLine(Object.ReferenceEquals(o1, o2)); // False

Console.WriteLine(e.Equals(d)); // True
Console.WriteLine(Object.Equals(e, d)); // True
Console.WriteLine(Object.ReferenceEquals(e, d)); // False