string.Equals() 和 == 运算符真的一样吗？ [复制]

Question

它们真的一样吗？今天，我遇到了这个问题。这是来自即时窗口的转储：

?s 
"Category" 
?tvi.Header 
"Category" 
?s == tvi.Header 
false 
?s.Equals(tvi.Header) 
true 
?s == tvi.Header.ToString() 
true 

所以，s 和 tvi.Header 都包含“类别”，但 == 返回 false，Equals() 返回 true。

s被定义为字符串，tvi.Header实际上是一个WPFTreeViewItem.Header。那么，为什么他们会返回不同的结果呢？我一直认为它们在 C# 中是可以互换的。

谁能解释这是为什么？

Answer 1

两个区别：

• Equals 是多态的（即它可以被覆盖，并且使用的实现将取决于目标对象的执行时类型），而使用的== 的实现是基于编译确定的-time 对象的类型：

    // Avoid getting confused by interning
    object x = new StringBuilder("hello").ToString();
    object y = new StringBuilder("hello").ToString();
    if (x.Equals(y)) // Yes
  
    // The compiler doesn't know to call ==(string, string) so it generates
    // a reference comparision instead
    if (x == y) // No
  
    string xs = (string) x;
    string ys = (string) y;
  
    // Now *this* will call ==(string, string), comparing values appropriately
    if (xs == ys) // Yes
  

• Equals 在 null 上调用它会抛出异常，== 不会

    string x = null;
    string y = null;
  
    if (x.Equals(y)) // NullReferenceException
  
    if (x == y) // Yes
  

请注意，使用object.Equals 可以避免后者成为问题：

if (object.Equals(x, y)) // Fine even if x or y is null

Answer 2

问题中出现明显的矛盾是因为在一种情况下，Equals 函数是在 string 对象上调用的，而在另一种情况下，== 运算符是在 System.Object 类型上调用的。 string 和 object 实现相等的方式彼此不同（分别是值与引用）。

除此之外，任何类型都可以以不同的方式定义== 和Equals，因此它们通常不可互换。

这是一个使用 double 的示例（来自 Joseph Albahari 对 C# 语言规范第 7.9.2 节的注释）：

double x = double.NaN;
Console.WriteLine (x == x);         // False
Console.WriteLine (x != x);         // True
Console.WriteLine (x.Equals(x));    // True

他接着说double.Equals(double) 方法旨在正确处理列表和字典。另一方面，== 运算符旨在遵循浮点类型的 IEEE 754 标准。

在确定字符串相等性的特定情况下，行业偏好是大多数时间既不使用==，也不使用string.Equals(string)。这些方法确定两个字符串是否逐个字符相同，这很少是正确的行为。最好使用string.Equals(string, StringComparison)，它允许您指定特定类型的比较。通过使用正确的比较，您可以避免很多潜在的（非常难以诊断的）错误。

这是一个例子：

string one = "Caf\u00e9";        // U+00E9 LATIN SMALL LETTER E WITH ACUTE
string two = "Cafe\u0301";       // U+0301 COMBINING ACUTE ACCENT
Console.WriteLine(one == two);                                          // False
Console.WriteLine(one.Equals(two));                                     // False
Console.WriteLine(one.Equals(two, StringComparison.InvariantCulture));  // True

此示例中的两个字符串看起来相同（“Café”），因此如果使用简单（序数）相等，这可能很难调试。

Answer 3

C# 有两个“等于”概念：Equals 和 ReferenceEquals。对于您将遇到的大多数类，== 运算符使用一个或另一个（或两者），并且通常仅在处理引用类型时测试 ReferenceEquals（但 string 类是 C# 已经知道如何测试值相等）。

• Equals 比较值。 （即使两个独立的int 变量不存在于内存中的同一位置，它们仍然可以包含相同的值。）
• ReferenceEquals 比较引用并返回操作数是否指向内存中的同一个对象。

示例代码：

var s1 = new StringBuilder("str");
var s2 = new StringBuilder("str");
StringBuilder sNull = null;

s1.Equals(s2); // True
object.ReferenceEquals(s1, s2); // False
s1 == s2 // True - it calls Equals within operator overload
s1 == sNull // False
object.ReferenceEquals(s1, sNull); // False
s1.Equals(sNull); // Nono!  Explode (Exception)

Answer 4

TreeViewItem 的Header 属性被静态类型化为object 类型。

因此== 产生false。您可以使用以下简单的 sn-p 重现这一点：

object s1 = "Hallo";

// don't use a string literal to avoid interning
string s2 = new string(new char[] { 'H', 'a', 'l', 'l', 'o' });

bool equals = s1 == s2;         // equals is false
equals = string.Equals(s1, s2); // equals is true

Answer 5

除了Jon Skeet's answer，我想解释一下为什么大多数时候在使用== 时，你实际上会在具有相同值的不同字符串实例上得到true 的答案：

string a = "Hell";
string b = "Hello";
a = a + "o";
Console.WriteLine(a == b);

如您所见，a 和 b 必须是不同的字符串实例，但由于字符串是不可变的，运行时使用所谓的 string interning 来让 a 和 b 引用相同的字符串记忆。对象的== 运算符检查引用，由于a 和b 都引用同一个实例，结果是true。当您更改其中任何一个时，都会创建一个新的字符串实例，这就是为什么可以进行字符串实习的原因。

顺便说一句，Jon Skeet 的回答并不完整。确实，x == y 是 false，但这只是因为他在比较对象，而对象是通过引用进行比较的。如果你写(string)x == (string)y，它将再次返回true。所以字符串的 == 运算符重载，它在下面调用 String.Equals。

Answer 6

这里有很多描述性的答案，所以我不会重复已经说过的内容。我想添加的是以下代码，展示了我能想到的所有排列。由于组合的数量，代码很长。随意将其放入 MSTest 并自己查看输出（输出包含在底部）。

这个证据支持 Jon Skeet 的回答。

代码：

[TestMethod]
public void StringEqualsMethodVsOperator()
{
    string s1 = new StringBuilder("string").ToString();
    string s2 = new StringBuilder("string").ToString();

    Debug.WriteLine("string a = \"string\";");
    Debug.WriteLine("string b = \"string\";");

    TryAllStringComparisons(s1, s2);

    s1 = null;
    s2 = null;

    Debug.WriteLine(string.Join(string.Empty, Enumerable.Repeat("-", 20)));
    Debug.WriteLine(string.Empty);
    Debug.WriteLine("string a = null;");
    Debug.WriteLine("string b = null;");

    TryAllStringComparisons(s1, s2);
}
private void TryAllStringComparisons(string s1, string s2)
{
    Debug.WriteLine(string.Empty);
    Debug.WriteLine("-- string.Equals --");
    Debug.WriteLine(string.Empty);
    Try((a, b) => string.Equals(a, b), s1, s2);
    Try((a, b) => string.Equals((object)a, b), s1, s2);
    Try((a, b) => string.Equals(a, (object)b), s1, s2);
    Try((a, b) => string.Equals((object)a, (object)b), s1, s2);

    Debug.WriteLine(string.Empty);
    Debug.WriteLine("-- object.Equals --");
    Debug.WriteLine(string.Empty);
    Try((a, b) => object.Equals(a, b), s1, s2);
    Try((a, b) => object.Equals((object)a, b), s1, s2);
    Try((a, b) => object.Equals(a, (object)b), s1, s2);
    Try((a, b) => object.Equals((object)a, (object)b), s1, s2);

    Debug.WriteLine(string.Empty);
    Debug.WriteLine("-- a.Equals(b) --");
    Debug.WriteLine(string.Empty);
    Try((a, b) => a.Equals(b), s1, s2);
    Try((a, b) => a.Equals((object)b), s1, s2);
    Try((a, b) => ((object)a).Equals(b), s1, s2);
    Try((a, b) => ((object)a).Equals((object)b), s1, s2);

    Debug.WriteLine(string.Empty);
    Debug.WriteLine("-- a == b --");
    Debug.WriteLine(string.Empty);
    Try((a, b) => a == b, s1, s2);
#pragma warning disable 252
    Try((a, b) => (object)a == b, s1, s2);
#pragma warning restore 252
#pragma warning disable 253
    Try((a, b) => a == (object)b, s1, s2);
#pragma warning restore 253
    Try((a, b) => (object)a == (object)b, s1, s2);
}
public void Try<T1, T2, T3>(Expression<Func<T1, T2, T3>> tryFunc, T1 in1, T2 in2)
{
    T3 out1;

    Try(tryFunc, e => { }, in1, in2, out out1);
}
public bool Try<T1, T2, T3>(Expression<Func<T1, T2, T3>> tryFunc, Action<Exception> catchFunc, T1 in1, T2 in2, out T3 out1)
{
    bool success = true;
    out1 = default(T3);

    try
    {
        out1 = tryFunc.Compile()(in1, in2);
        Debug.WriteLine("{0}: {1}", tryFunc.Body.ToString(), out1);
    }
    catch (Exception ex)
    {
        Debug.WriteLine("{0}: {1} - {2}", tryFunc.Body.ToString(), ex.GetType().ToString(), ex.Message);
        success = false;
        catchFunc(ex);
    }

    return success;
}

输出：

string a = "string";
string b = "string";

-- string.Equals --

Equals(a, b): True
Equals(Convert(a), b): True
Equals(a, Convert(b)): True
Equals(Convert(a), Convert(b)): True

-- object.Equals --

Equals(a, b): True
Equals(Convert(a), b): True
Equals(a, Convert(b)): True
Equals(Convert(a), Convert(b)): True

-- a.Equals(b) --

a.Equals(b): True
a.Equals(Convert(b)): True
Convert(a).Equals(b): True
Convert(a).Equals(Convert(b)): True

-- a == b --

(a == b): True
(Convert(a) == b): False
(a == Convert(b)): False
(Convert(a) == Convert(b)): False
--------------------

string a = null;
string b = null;

-- string.Equals --

Equals(a, b): True
Equals(Convert(a), b): True
Equals(a, Convert(b)): True
Equals(Convert(a), Convert(b)): True

-- object.Equals --

Equals(a, b): True
Equals(Convert(a), b): True
Equals(a, Convert(b)): True
Equals(Convert(a), Convert(b)): True

-- a.Equals(b) --

a.Equals(b): System.NullReferenceException - Object reference not set to an instance of an object.
a.Equals(Convert(b)): System.NullReferenceException - Object reference not set to an instance of an object.
Convert(a).Equals(b): System.NullReferenceException - Object reference not set to an instance of an object.
Convert(a).Equals(Convert(b)): System.NullReferenceException - Object reference not set to an instance of an object.

-- a == b --

(a == b): True
(Convert(a) == b): True
(a == Convert(b)): True
(Convert(a) == Convert(b)): True

Answer 7

很明显tvi.header 不是String。 == 是一个被String 类重载的运算符，这意味着它只有在编译器知道运算符的两边都是String 时才能工作。

Answer 8

对象由唯一的 OBJECT_ID 定义。如果 A 和 B 是对象并且 A == B 为真，那么它们就是同一个对象，它们具有相同的数据和方法，但是，这也是真的：

A.OBJECT_ID == B.OBJECT_ID

如果 A.Equals(B) 为真，表示两个对象处于相同的状态，但这并不意味着 A 和 B 完全一样。

字符串是对象。

请注意，== 和 Equals 运算符是自反的、同分的、传递的，因此它们是等价关系（使用关系代数术语）

这意味着什么： 如果A、B、C是对象，那么：

(1) A == A 始终为真； A.Equals(A) 始终为真（自反性）

(2) 如果 A == B 那么 B == A;如果 A.Equals(B) 则 B.Equals(A) (simetry)

(3) 如果 A == B 且 B == C，则 A == C； if A.Equals(B) and B.Equals(C) then A.Equals(C) (transzitivity)

另外，你可以注意到这也是正确的：

(A == B) => (A.Equals(B))，但反之不成立。

A B =>
0 0 1
0 1 1
1 0 0
1 1 1

现实生活的例子： 相同类型的两个汉堡包具有相同的属性：它们是汉堡包类的对象，它们的属性完全相同，但它们是不同的实体。如果你买了这两个汉堡，吃了一个，另一个就吃不下了。因此，Equals 和 == 之间的区别： 你有 hamburger1 和 hamburger2。它们完全处于相同的状态（相同的重量、相同的温度、相同的味道），所以 hamburger1.Equals(hamburger2) 为真。但是hamburger1 == hamburger2是假的，因为如果hamburger1的状态改变了，hamburger2的状态不一定改变，反之亦然。

如果你和一个朋友同时得到一个汉堡包，这是你和他的，那么你必须决定把汉堡包分成两部分，因为 you.getHamburger() == friend.getHamburger() 是 true 并且如果发生这种情况：friend.eatHamburger()，那么你的汉堡也会被吃掉。

我可以写关于 Equals 和 == 的其他细微差别，但我饿了，所以我必须走了。

最好的问候， 拉霍斯阿帕德。