它们真的是相同的吗？今天我遇到了这个问题。这里是从立即窗口中获取的转储：
?s
"Category"
?tvi.Header
"Category"
?s == tvi.Header
false
?s.Equals(tvi.Header)
true
?s == tvi.Header.ToString()
true
s和tvi.Header都包含"Category"，但==返回false，Equals()返回true。 s被定义为字符串，tvi.Header实际上是WPF的TreeViewItem.Header。那么为什么它们返回不同的结果？我一直以为在C#中它们是可以互换的。有人能解释一下为什么吗？两个不同之处：
Equals is polymorphic (i.e. it can be overridden, and the implementation used will depend on the execution-time type of the target object), whereas the implementation of == used is determined based on the compile-time types of the objects:
// 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 will throw an exception if you call it on null, == won't
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
String.Equals(x, y)而不是object.Equals(x, y)是否更合理？ - Chaulkyobject.Equals更能避免空问题呢？唯一的好处是它限制了两个值都必须是string类型。 - Jon Skeetobject.Equals(x, y) 相比，这种类型检查是它的优势。问题是关于字符串比较的，因此使用 String.Equals() 的优点似乎在于增加了类型检查。避免进行类型检查是否更好？另外，感谢您回答一年前的评论！ - Chaulkyobject.Equals 始终可用于避免空引用问题，而对于特定类型，我需要检查文档:) - Jon Skeet问题中出现的表面矛盾是因为在一个情况下，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é"），所以如果使用天真的（序数）相等性来比较，这可能会非常棘手。
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)
== 比较两个实际的字符串对象，它们具有不同的引用但相同的值，你会得到 true。Jon Skeet 解释了这个问题... - Noldorin==”运算符有时必须在它们之间进行选择，并且通常在处理可空类型时选择“ReferenceEquals”。 string是C＃不仅使用“ReferenceEquals”的可空类型的示例。 OP询问了关于string对象，但实际上需要了解一般的C＃对象。 - palswim==运算符，其行为取决于其操作数。因为运算符是重载的，实际上有许多==运算符，每个运算符都有其实现者给出的任何行为。编译器根据两个操作数的编译时类型选择特定的运算符。规定该选择的规则在C#规范版本5.0的第7.3节“运算符”中描述。 - phoogTreeViewItem的Header属性是静态类型，类型为object。
因此==返回false。您可以使用以下简单代码片段重现此问题：
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
s1和s2都声明为字符串时，s1 == s2变为s1.Equals(s2)。在C#中，字符串相等具有特殊含义。 - Jeff Mercado == 时，您实际上会在具有相同值的不同字符串实例上得到答案 true ：string a = "Hell";
string b = "Hello";
a = a + "o";
Console.WriteLine(a == b);
a和b必须是不同的字符串实例，但由于字符串是不可变的，运行时使用所谓的string interning来让a和b引用相同的内存中的字符串。对象的==运算符检查引用，因为a和b都引用相同的实例，所以结果是true。当您更改其中任何一个时，会创建一个新的字符串实例，这就是为什么字符串插入是可能的原因。x == y是false，但这只是因为他在比较对象，对象按引用比较。如果您编写(string)x == (string)y，它将再次返回true。因此，字符串具有其==运算符重载，该运算符在底层调用String.Equals。a和b指向不同的实例；字符串驻留仅适用于编译时常量。你的代码打印True是因为调用了==重载函数，它比较字符序列。最终a所引用的字符串并没有被驻留。 - Jon Skeeta最终引用的字符串没有被池化？是因为在比较时无法确定a的编译时值吗？初始值“Hell”会被池化吗？ - Ax.b，"Hello" 也会存在于内部池中；但 a 将是调用 String.Concat("Hell", "o"); 的结果。 - 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
很明显，tvi.header不是一个String类型。 ==是由String类重载的运算符，这意味着它只有在编译器知道运算符两侧都是String类型时才能正常工作。
A B =>
0 0 1
0 1 1
1 0 0
1 1 1
StringComparison参数的string.Equals重载。对于编码字符串（例如 XML 属性），请使用 InvarientCulture 版本；对于用户输入的字符串，请使用 CurrentCulture 版本。这将处理许多==忽略的细节，例如 Unicode 字符规范化形式等，并使大小写敏感性明确。 - Jeffrey L Whitledge