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

84

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

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

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

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

但是C＃站指出：

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

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

c#  equality 
— 999999
source
1
— pinichi 2010年
请参阅stackoverflow.com/questions/814878/…以及有关此主题的许多其他StackOverflow问题。
— 伊恩·默瑟
@高我有。只是我从C＃Station中提取的部分让我感到困惑。
— 999999年

Answers:

87

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

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

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

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

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
— 安妮
source
那么上面引用的C＃站摘录是否错误（特别是如果我重写.Equals()）？
— 999999年
1
摘录说“在object课堂上”。我想您跳过了那部分？因为否则您将不会谈论覆盖它。
— 多梅尼克（Domenic），2010年
1
我的答案只关于object班级。
— 阿妮2010年
@Ani：您的以下句子是错误的静态方法可以引发NullReferenceException：由于它是静态的（不与对象实例关联），因此在任何情况下都不会引发aNullReferenceException。
— selvaraj
2
Equals也是一个带有object两个参数的静态方法。一个或两个都可以null。
— weston 2012年
20

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

我认为有关的要点是：

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

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

希望这可以帮助！

— 阿拉斯泰尔·皮茨
source
6
不幸的是，链接已死。+1用于复制相关信息。
— Pac0
6

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

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

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

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

— 卢克·谢弗
source
3

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

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

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

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

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

— 索托尼卡
source
1

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

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

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

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

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

— 约拉
source
1

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

。

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);
    }
}
— 约翰·贝文
source
-3

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
— 阿图利亚
source
3
这是无稽之谈。Equals和ReferenceEquals都不会查看HashCode。仅存在一个要求，即Equals对象的HashCodes必须相等。并且对象不会指向任何地方...当且仅当其两个参数都是相同的引用对象或两个都为null时，ReferenceEquals才为true。
— 吉姆·巴尔特
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.