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

Equals只是一个虚方法，因此将使用重写的版本(对于字符串类型比较内容)。

当比较对象引用和字符串时(即使对象引用引用了字符串)，特定于字符串类的==操作符的特殊行为将被忽略。

Normally (when not dealing with strings, that is), Equals compares values, while == compares object references. If two objects you are comparing are referring to the same exact instance of an object, then both will return true, but if one has the same content and came from a different source (is a separate instance with the same data), only Equals will return true. However, as noted in the comments, string is a special case because it overrides the == operator so that when dealing purely with string references (and not object references), only the values are compared even if they are separate instances. The following code illustrates the subtle differences in behaviors:

string s1 = "test";
string s2 = "test";
string s3 = "test1".Substring(0, 4);
object s4 = s3;  // Notice: set to object variable!

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     // s1, s2
False True True    // s1, s3
False False True   // s1, s4

简介:

==和. equals都依赖于实际类型中定义的行为和调用位置上的实际类型。两者都只是方法/操作符，可以在任何类型上重写，并给定作者希望的任何行为。根据我的经验，我发现人们在对象上实现. equals却忽略了operator ==是很常见的。这意味着. equals将实际测量值是否相等，而==将测量它们是否是相同的引用。

当我处理一个定义不断变化的新类型或编写泛型算法时，我发现最佳实践如下

如果我想在c#中比较引用，我使用Object。直接使用ReferenceEquals(在泛型情况下不需要) 如果我想比较值，我使用EqualityComparer<T>。默认的

在某些情况下，当我觉得==的用法不明确时，我会显式地使用Object。在代码中引用等号以消除歧义。

Eric Lippert最近写了一篇博文，主题是为什么在CLR中有两种相等的方法。值得一读

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

I am a bit confused here. If the runtime type of Content is of type string, then both == and Equals should return true. However, since this does not appear to be the case, then runtime type of Content is not string and calling Equals on it is doing a referential equality and this explains why Equals("Energy Attack") fails. However, in the second case, the decision as to which overloaded == static operator should be called is made at compile time and this decision appears to be ==(string,string). this suggests to me that Content provides an implicit conversion to string.

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

可能出现意外的参考比较;为了进行价值比较， 转换左侧以输入'string'

给答案再加一分。

. equalsto()方法提供了比较区域性和区分大小写的方法。

= =操作符

如果操作数为值类型且值相等，则返回true否则为false。 如果操作数是引用类型(string除外)，并且都引用同一个实例(同一对象)，则返回true否则返回false。 如果操作数为字符串类型且值相等，则返回true否则返回false。

.Equals

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

首先，两者有区别。对数字的

> 2 == 2.0
True

> 2.Equals(2.0)
False

对于字符串

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

> x.Equals(null)
NullReferenceException

在这两种情况下，==比.Equals更有用

The == token in C# is used for two different equality-check operators. When the compiler encounters that token, it will check whether either of the types being compared has implemented an equality-operator overload for either the specific combination types being compared(*), or for a combination of types to which both types can be converted. If the compiler finds such an overload it will use it. Otherwise, if the two types are both reference types and they are not unrelated classes (either may be an interface, or they may be related classes), the compiler will regard == as a reference-comparison operator. If neither condition applies, compilation will fail.

请注意，其他一些语言为两个相等检查操作符使用单独的令牌。在VB。例如，=令牌在表达式中仅用于可重载的相等检查操作符，而is则用作引用测试或空测试操作符。在没有覆盖相等检查操作符的类型上使用=将会失败，在测试引用是否相等或为空之外的任何目的上尝试使用Is也会失败。

(*)Types generally only overload equality for comparison with themselves, but it may be useful for types to overload the equality operator for comparison with other particular types; for example, int could have (and IMHO should have but didn't) defined an equality operators for comparison with float, so that 16777217 would not report itself equal to 16777216f. As it is, since no such operator is defined, C# will promote the int to float, rounding it to 16777216f before the equality-check operator sees it; that operator then sees two equal floating-point numbers and reports them as equal, unaware of the rounding that took place.

当我们创建任何对象时，对象有两个部分，一个是内容，另一个是对该内容的引用。 ==比较内容和引用; 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的左边有更多的0，但我们在这里不关心它。

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是假的

a和c的位模式是相同的，所以使用==它们是相等的。

等于():

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

例如两个不同的String对象都表示“Jane”中的字符

Equal和==之间的唯一区别是对象类型比较。在其他情况下，例如引用类型和值类型，它们几乎是相同的(要么都是位相等，要么都是引用相等)。

对象: Equals:位的相等 ==:引用相等

String:(equals和==对于String是相同的，但如果字符串中的一个被更改为object，则比较结果将不同) Equals:位的相等 ==:位相等

更多的解释请看这里。

@BlueMonkMN早前的回答还有另一个层面。额外的维度是，@Drahcir的标题问题的答案也取决于我们如何得到字符串值。说明:

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

非常棒的答案和例子!

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

像==这样的操作符不是多态的，而Equals是

记住这个概念，如果你算出任何例子(通过查看左手和右手引用类型，并检查/知道类型是否确实重载了==操作符和重写了Equals)，你肯定会得到正确的答案。

据我所知，答案很简单:

==比较对象引用。 . equals比较对象内容。 字符串数据类型的作用总是类似于内容比较。

我希望我是对的，这回答了你的问题。

因为到目前为止还没有提到. 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不完全相同，所以可以使用静态String。改为= method。这样，如果两边不是相同的类型，您仍然可以比较内容，如果其中一方为空，则可以避免异常。

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

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

以下是从微软复制的一些信息:

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

参数

一个字符串

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

b字符串

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

返回布尔值

如果a的值与b的值相同，则为真;否则,假的。如果a和b都为空，则该方法返回true。

作为对已经很好的答案的补充:这种行为不仅限于字符串或比较不同的数字类型。即使两个元素的类型对象都是相同的基础类型。“==”不行。

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

注意，在c#中有两种不同类型的等式

1-值相等(对于int, DateTime和struct等值类型)

2-引用平等(对象)

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

1- ==和!=运算符。

2- virtual Equals方法。

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

例如值类型

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

但是对于参考类型

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

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

例如，在下面的例子中，在运行时，将决定Equals()将应用于int值，结果为真。

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使用结构比较，这意味着它对struct的每个字段调用Equals。

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

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

现在更容易理解了，equal方法也有两个实现一个来自string类本身，一个来自object类。它对性能的影响以及我也运行一些基本的代码，并试图理解基准测试。

我分享下面的结果，如果我错了，请纠正或建议。有3种情况，我对所有情况运行了相同的代码，这就是结果。

情况1:这里我使用的是字符串。相等的方法比较两个字符串和两个字符串有相同的值。string.equals (a, b)

第一次运行:5608195 tick

第二次运行:5529387个刻度

第三次运行:5622569滴答

总蜱数:16760151

情况2:这里我使用的是字符串。Equal()方法(重载的一个)用于比较两个字符串，并且两个字符串具有相同的值。 a.equals (b)

第一次运行:6738583滴答

第二轮:6452927

第三轮:7168897个刻度

总蜱虫= 20360407

情况3:这里我使用==操作符比较2个字符串，两个字符串都有相同的值。 a = =

第一次运行:6652151滴答

第二次运行:7514300个tick

第三轮: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++;
        }
    }
}

Equals()和==是否相同取决于实现。因为c#允许用户分别为Equals()和==设置不同的行为。

    class CompareTest
    {
        public readonly int val;

        public CompareTest(int val)
        {
            this.val = val;
        }

        public override bool Equals(object obj)
        {
            return obj is CompareTest test && this.val == test.val;
        }

        public override int GetHashCode()
        {
            return val;
        }

        public static bool operator == (CompareTest a, object b)
        {
            return Equals(a, b);
        }

        public static bool operator != (CompareTest a, object b)
        {
            return !(a == b);
        }
    }

在本例中，我使Equals()和==具有相同的行为。但如果我让他们不一样呢?例如:

        public static bool operator == (CompareTest a, object b)
        {
            return false;
        }

Equals()正常工作，但==永远不会工作。

此外，虽然我让它们具有相同的行为，但仍然有一个区别:哪个==函数将被调用取决于左边的值:

        Compare Test a = new CompareTest(1);
        object b = new CompareTest(1);
        CompareTest c = new CompareTest(1);
        Debug.Log("AB " + (a == b)); // true
        Debug.Log("BA " + (b == a)); // false! because it calls object's == function 
        Debug.Log("AC " + (a == c)); // true
        Debug.Log("CA " + (c == a)); // true