== 和 Equals() 之间的 C# 区别

当 == 用于 object 类型的表达式时，它将解析为 System.Object.ReferenceEquals。

Equals 只是一个 virtual 方法并且行为如此，因此将使用被覆盖的版本（对于 string 类型比较内容）。

---

将对象引用与字符串进行比较时（即使对象引用引用了字符串），将忽略特定于字符串类的 == 运算符的特殊行为。

通常（即不处理字符串时），Equals 比较 值，而 == 比较 对象引用。如果您要比较的两个对象指的是同一个对象的确切实例，则两者都将返回 true，但如果一个对象具有相同的内容并且来自不同的源（是具有相同数据的单独实例），则只有 Equals 会返回真。但是，正如评论中所指出的，字符串是一种特殊情况，因为它覆盖了 == 运算符，因此在纯粹处理字符串引用（而不是对象引用）时，即使它们是单独的实例，也只会比较这些值。以下代码说明了行为的细微差别：

string s1 = "test";
string s2 = "test";
string s3 = "test1".Substring(0, 4);
object s4 = s3;

Console.WriteLine($"{object.ReferenceEquals(s1, s2)} {s1 == s2} {s1.Equals(s2)}");
Console.WriteLine($"{object.ReferenceEquals(s1, s3)} {s1 == s3} {s1.Equals(s3)}");
Console.WriteLine($"{object.ReferenceEquals(s1, s4)} {s1 == s4} {s1.Equals(s4)}");

输出是：

True True True
False True True
False False True

---

== 和 .Equals 都依赖于实际类型中定义的行为和调用站点的实际类型。两者都只是方法/运算符，可以在任何类型上重写并给出作者想要的任何行为。根据我的经验，我发现人们在对象上实现 .Equals 而忽略实现运算符 == 是很常见的。这意味着 .Equals 将实际测量值的相等性，而 == 将测量它们是否是相同的参考。

当我使用定义不断变化的新类型或编写通用算法时，我发现最佳实践如下

如果我想比较 C# 中的引用，我直接使用 Object.ReferenceEquals （在一般情况下不需要）

如果我想比较值，我使用 EqualityComparer.Default

在某些情况下，当我觉得 == 的用法不明确时，我会在代码中明确使用 Object.Reference equals 来消除歧义。

Eric Lippert 最近发表了一篇关于为什么 CLR 中有两种相等方法的博客文章。值得一读

http://blogs.msdn.com/ericlippert/archive/2009/04/09/double-your-dispatch-double-your-fun.aspx

---

== 运算符

如果操作数是值类型并且它们的值相等，则返回 true，否则返回 false。如果操作数是除字符串以外的引用类型并且都引用同一个实例（同一个对象），则返回 true 否则返回 false。如果操作数是字符串类型并且它们的值相等，则返回 true，否则返回 false。

。等于

如果操作数是引用类型，则执行引用相等，即如果两者都引用同一个实例（同一个对象），则返回 true，否则返回 false。如果操作数是值类型，则与 == 运算符不同，它首先检查它们的类型，如果它们的类型相同，则执行 == 运算符，否则返回 false。

---

据我了解，答案很简单：

== 比较对象引用。 .Equals 比较对象内容。字符串数据类型总是像内容比较一样。

我希望我是正确的，它回答了你的问题。

---

首先，有区别。对于数字

> 2 == 2.0
True

> 2.Equals(2.0)
False

对于字符串

> string x = null;
> x == null
True

> x.Equals(null)
NullReferenceException

在这两种情况下，== 的行为都比 .Equals 更有用

---

我要补充一点，如果您将对象转换为字符串，那么它将正常工作。这就是为什么编译器会给你一个警告说：

可能的意外参考比较；要进行值比较，请将左侧转换为“字符串”

---

就像对已经很好的答案的补充一样：这种行为不仅限于字符串或比较不同的数字类型。即使两个元素都是相同底层类型的对象类型。 “==”不起作用。

以下屏幕截图显示了比较两个对象 {int} - 值的结果

https://i.stack.imgur.com/fbeUg.png

---

因为到目前为止还没有提到 .Equal 方法的静态版本，所以我想在这里添加它来总结和比较 3 种变体。

MyString.Equals("Somestring"))          //Method 1
MyString == "Somestring"                //Method 2
String.Equals("Somestring", MyString);  //Method 3 (static String.Equals method) - better

其中 MyString 是来自代码中其他地方的变量。

背景信息和总结：

在 Java 中，不应使用 == 来比较字符串。如果您需要同时使用这两种语言，我会提到这一点，并让您知道使用 == 也可以用 C# 中更好的东西代替。

在 C# 中，使用方法 1 或方法 2 比较字符串没有实际区别，只要两者都是字符串类型。但是，如果一个为空，一个是另一种类型（如整数），或者一个表示具有不同引用的对象，那么，正如最初的问题所示，您可能会遇到比较内容是否相等可能不会返回什么你期望。

建议的解决方案：

因为在比较事物时使用 == 与使用 .Equals 并不完全相同，您可以改用 static String.Equals 方法。这样，如果两边不是同一个类型，你仍然会比较内容，如果一个为空，你将避免异常。

   bool areEqual = String.Equals("Somestring", MyString);  

写起来有点多，但在我看来，使用起来更安全。

以下是从 Microsoft 复制的一些信息：

public static bool Equals (string a, string b);

参数

a 字符串

要比较的第一个字符串，或 null。

b 字符串

要比较的第二个字符串，或 null。

返回 Boolean

true 如果 a 的值与 b 的值相同；否则，false。如果 a 和 b 都是 null，则该方法返回 true。

---

我在这里有点困惑。如果 Content 的运行时类型是字符串类型，那么 == 和 Equals 都应该返回 true。但是，由于情况似乎并非如此，因此 Content 的运行时类型不是字符串，并且在其上调用 Equals 正在执行引用相等，这解释了 Equals("Energy Attack") 失败的原因。然而，在第二种情况下，关于应该调用哪个重载的 == 静态运算符的决定是在编译时做出的，这个决定似乎是 ==(string,string)。这向我表明 Content 提供了对字符串的隐式转换。

---

@BlueMonkMN 的早期回答还有另一个维度。另一个维度是，@Drahcir 的标题问题的答案也取决于我们如何获得 string 值。为了显示：

string s1 = "test";
string s2 = "test";
string s3 = "test1".Substring(0, 4);
object s4 = s3;
string s5 = "te" + "st";
object s6 = s5;
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s2), s1 == s2, s1.Equals(s2));

Console.WriteLine("\n  Case1 - A method changes the value:");
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s3), s1 == s3, s1.Equals(s3));
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s4), s1 == s4, s1.Equals(s4));

Console.WriteLine("\n  Case2 - Having only literals allows to arrive at a literal:");
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s5), s1 == s5, s1.Equals(s5));
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s6), s1 == s6, s1.Equals(s6));

输出是：

True True True

  Case1 - A method changes the value:
False True True
False False True

  Case2 - Having only literals allows to arrive at a literal:
True True True
True True True

---

为答案再添一分。

.EqualsTo() 方法让您可以根据文化和区分大小写进行比较。

---

真的很棒的答案和例子！

我只想补充一下两者之间的根本区别，

== 等运算符不是多态的，而 Equals 是

考虑到这个概念，如果您提出任何示例（通过查看左手和右手引用类型，并检查/了解该类型是否实际上重载了 == 运算符并且 Equals 被覆盖），您肯定会得到正确的答案.

---

这是由于值相等（equal 方法）和引用相等（== 运算符），因为 equal 方法检查值，而相同的 == 检查引用。

== https://referencesource.microsoft.com/ 上的字符串类中可用的运算符覆盖代码

所以现在更容易理解了，equal 方法也有两种实现，一种来自字符串类本身，一种来自对象类。它对性能的影响以及我还运行一些基本代码并尝试了解基准。

我在下面分享结果如果我在某处错了，请更正或建议。有 3 个案例，我为所有案例运行了相同的代码，这就是结果。

案例1：这里我使用的是字符串。 equal 方法比较两个字符串并且两个字符串具有相同的值。 string.equals(a,b)

第一次运行：5608195 滴答

第二次运行：5529387 滴答声

第三次运行：5622569 滴答声

总刻度：16760151

案例2：这里我使用的是字符串。 equal() 方法（重载一个）用于比较 2 个字符串并且两个字符串具有相同的值。 a.等于(b)

第一次运行：6738583 滴答声

第二次运行：6452927 滴答声

第三次运行：7168897 滴答声

总刻度=20360407

案例 3：这里我使用 == 运算符比较 2 个字符串，并且两个字符串具有相同的值。 a==b

第一次运行：6652151 滴答声

第二次运行：7514300 滴答

第三次运行：7634606 滴答声

总刻度=21801057

class Program
{
    private static int count;
    static string a = "abcdef";
    static string b = "abcdef";
    static void Main(string[] args)
    {            

        for (int j = 1; j <= 3; j++)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            for (int i = 1; i <= 1000; i++)
            {
                checkString();
            }
            sw.Stop();
            Console.WriteLine(sw.ElapsedTicks);
        }
        Console.ReadLine();

    }
    public static void checkString()
    {
        for (int i = 1; i <= 100000; i++)
        {
            if (a==b)
                count++;
        }
    }
}

---

C# 中的 == 标记用于两个不同的相等检查运算符。当编译器遇到该标记时，它将检查被比较的任何一个类型是否已经为被比较的特定组合类型（*）或两种类型都可以转换为的类型组合实现了相等运算符重载。如果编译器发现这样的重载，它将使用它。否则，如果这两种类型都是引用类型并且它们不是不相关的类（可能是接口，也可能是相关类），编译器会将 == 视为引用比较运算符。如果两个条件都不适用，编译将失败。

请注意，其他一些语言对两个相等检查运算符使用单独的标记。例如，在 VB.NET 中，= 标记在表达式中仅用于可重载的相等检查运算符，而 Is 用作引用测试或空测试运算符。在不覆盖相等检查运算符的类型上使用 = 将失败，尝试将 Is 用于测试引用相等或无效性以外的任何目的也会失败。

(*) 类型通常仅重载相等性以便与自身进行比较，但对于类型而言重载相等性运算符以与其他特定类型进行比较可能很有用；例如，int 可以（恕我直言，应该有但没有）定义一个相等运算符用于与 float 进行比较，因此 16777217 不会报告自己等于 16777216f。事实上，由于没有定义这样的运算符，C# 会将 int 提升为 float，在相等检查运算符看到它之前将其四舍五入为 16777216f；然后该运算符看到两个相等的浮点数并将它们报告为相等，而不知道发生的舍入。

---

请注意，C# 中有两种不同类型的相等

1- Value Equality（对于 int、DateTime 和 struct 等值类型）

2- Reference Equality（对于对象）

有两种基本的标准协议来实现相等检查。

1- == 和 != 运算符。

2- virtual Equals 方法。

== 和 != 是静态解析的，这意味着 C# 将在编译时决定哪种类型将执行比较。

例如 value-type

 int x = 50;
 int y = 50;
 Console.WriteLine (x == y); // True

但对于 reference type

 object x = 50;
 object y = 50;
 Console.WriteLine (x == y); // False 

Equals() 最初在运行时根据操作数实际类型解析。

例如，在以下示例中，在运行时，将决定 Equals() 将应用于 int 值，结果为 true。

object x = 5;
object y = 5;
Console.WriteLine (x.Equals (y)); // True

但是，对于引用类型，它将使用引用相等检查。

MyObject x = new MyObject();
MyObject y = x;
Console.WriteLine (x.Equals (y)); // True

请注意，Equals() 对 struct 使用结构比较，这意味着它在结构的每个字段上调用 Equals。

---

当我们创建任何对象时，对象有两个部分，一个是内容，另一个是对该内容的引用。 == 比较内容和参考； equals() 仅比较内容

http://www.codeproject.com/Articles/584128/What-is-the-difference-between-equalsequals-and-Eq

---

==

== 运算符可用于比较任何类型的两个变量，它只是比较位。

int a = 3;
byte b = 3;
if (a == b) { // true }

注意： int 的左侧有更多的零，但我们在这里不关心。

int a (00000011) == 字节 b (00000011)

请记住 == 运算符只关心变量中位的模式。

使用 == 如果两个引用（原语）引用堆上的同一个对象。

无论变量是引用还是原语，规则都是相同的。

Foo a = new Foo();
Foo b = new Foo();
Foo c = a;

if (a == b) { // false }
if (a == c) { // true }
if (b == c) { // false }

a == c 为真 a == b 为假

和 c 的位模式相同，因此使用 == 时它们相等。

平等的（）：

使用 equals() 方法查看两个不同的对象是否相等。

比如两个不同的String对象，都代表“简”中的字符

---

Equal 和 == 之间的唯一区别在于对象类型比较。在其他情况下，例如引用类型和值类型，它们几乎相同（两者都是按位相等或两者都是引用相等）。

对象：等于：按位相等 ==：引用相等

string: (equals 和 == 对于 string 是一样的，但是如果 string 之一变成了 object，那么比较结果会不同) Equals: 按位相等 == : 按位相等

有关详细说明，请参阅 here。

---