你为什么要使用String.Equals而不是==？

Question

我最近被介绍到一个大型代码库,并注意到所有的字符串比较都使用String.Equals()而不是==

你觉得这是什么原因？

Answer 1

很可能很大一部分开发人员基础来自Java背景,==用于比较字符串是错误的并且不起作用.

在C#中,只要它们被键入为字符串,就没有(实际)差异(对于字符串).

如果它们被输入object或者T在这里看到其他答案,那就是谈论泛型方法或运算符重载,你肯定想要使用Equals方法.

Answer 2

string.Equals和之间有实际的区别==

bool result = false;

object obj = "String";    
string str2 = "String";
string str3 = typeof(string).Name;
string str4 = "String";
object obj2 = str3;

// Comparision between object obj and string str2 -- Com 1
result = string.Equals(obj, str2);// true
result = String.ReferenceEquals(obj, str2); // true
result = (obj == str2);// true

// Comparision between object obj and string str3 -- Com 2
result = string.Equals(obj, str3);// true
result = String.ReferenceEquals(obj, str3); // false
result = (obj == str3);// false

// Comparision between object obj and string str4 -- Com 3
result = string.Equals(obj, str4);// true
result = String.ReferenceEquals(obj, str4); // true
result = (obj == str4);// true

// Comparision between string str2 and string str3 -- Com 4
result = string.Equals(str2, str3);// true
result = String.ReferenceEquals(str2, str3); // false
result = (str2 == str3);// true

// Comparision between string str2 and string str4 -- Com 5
result = string.Equals(str2, str4);// true
result = String.ReferenceEquals(str2, str4); // true
result = (str2 == str4);// true

// Comparision between string str3 and string str4 -- Com 6
result = string.Equals(str3, str4);// true
result = String.ReferenceEquals(str3, str4); // false
result = (str3 == str4);// true

// Comparision between object obj and object obj2 -- Com 7
result = String.Equals(obj, obj2);// true
result = String.ReferenceEquals(obj, obj2); // false
result = (obj == obj2);// false

添加手表

obj     "String" {1#}   object {string}
str2    "String" {1#}   string
str3    "String" {5#}   string
str4    "String" {1#}   string
obj2    "String" {5#}   object {string}

现在看看{1#}和{5#}

obj,str2,str4和obj2引用是相同的.

obj并且obj2是object type和其他人string type

结论:

1. com1:result =(obj == str2); // true
   • 比较object并string执行引用相等性检查
   • obj和str2指向相同的引用,因此结果为真
2. com2:result =(obj == str3); // false
   • 比较object并string执行引用相等性检查
   • obj和str3指向不同的引用,因此结果为false
3. com3:result =(obj == str4); // true
   • 比较object并string执行引用相等性检查
   • obj和str4指向相同的引用,因此结果为真
4. com4:result =(str2 == str3); // true
   • 比较string并string执行字符串值检查
   • str2和str3都是"String",因此结果为true
5. com5:result =(str2 == str4); // true
   • 比较string并string执行字符串值检查
   • str2和str4都是"String",因此结果为true
6. com6:result =(str3 == str4); // true
   • 比较string并string执行字符串值检查
   • str3和str4都是"String",因此结果为true
7. com7:result =(obj == obj2); // false - 比较object并object执行引用相等性检查 - obj和obj2指向不同的引用,结果为false

Answer 3

==和String.Equals方法之间有一个微妙但非常重要的区别:

class Program
{
    static void Main(string[] args)
    {
        CheckEquality("a", "a");
        Console.WriteLine("----------");
        CheckEquality("a", "ba".Substring(1));
    }

    static void CheckEquality<T>(T value1, T value2) where T : class
    {
        Console.WriteLine("value1: {0}", value1);
        Console.WriteLine("value2: {0}", value2);

        Console.WriteLine("value1 == value2:      {0}", value1 == value2);
        Console.WriteLine("value1.Equals(value2): {0}", value1.Equals(value2));

        if (typeof(T).IsEquivalentTo(typeof(string)))
        {
            string string1 = (string)(object)value1;
            string string2 = (string)(object)value2;
            Console.WriteLine("string1 == string2:    {0}", string1 == string2);
        }
    }
}

生成此输出:

value1: a
value2: a
value1 == value2:      True
value1.Equals(value2): True
string1 == string2:    True
----------
value1: a
value2: a
value1 == value2:      False
value1.Equals(value2): True
string1 == string2:    True

您可以看到==运算符返回false为两个明显相等的字符串.为什么？因为泛型方法中使用的==运算符被解析为System.Object定义的op_equal方法(方法在编译时具有的唯一保证),这意味着它是引用相等而不是值相等.

如果有两个值显式地键入System.String,则==具有值 - 相等语义,因为编译器将==解析为System.String.op_equal而不是System.Object.op_equal.

所以为了安全起见,我几乎总是使用String.Equals代替我总是得到我想要的值相等语义.

并且为了避免NullReferenceExceptions,如果其中一个值为null,我总是使用静态 String.Equals方法:

bool true = String.Equals("a", "ba".Substring(1));

Answer 4

String.Equals确实提供重载来处理套管和文化意识的比较.如果您的代码没有使用这些代码,那么开发人员可能只会习惯使用Java,其中(如Matthew所说),您必须使用.Equals方法进行内容比较.

Answer 5

两种方法都具有相同的功能 - 比较值.因为它是用MSDN编写的:

• 关于String.Equals方法 - 确定此实例和另一个指定的String对象是否具有相同的值.(http://msdn.microsoft.com/en-us/library/858x0yyx.aspx)
• 关于'==' - 尽管string是引用类型,但是定义了相等运算符(==和!=)来比较字符串对象的值,而不是引用.这使得对字符串相等性的测试更加直观.(http://msdn.microsoft.com/en-en/library/362314fe.aspx)

但是,如果您的一个字符串实例为null,则这些方法的工作方式不同:

string x = null;
string y = "qq";
if (x == y) // returns false
    MessageBox.Show("true");
else
    MessageBox.Show("false");

if (x.Equals(y)) // returns System.NullReferenceException: Object reference not set to an instance of an object. - because x is null !!!
    MessageBox.Show("true");
else
    MessageBox.Show("false");

Answer 6

有一个书面记录这篇文章,你可能会发现很有趣,从乔恩斯基特一些报价.似乎使用几乎是一样的.

Jon Skeet表示,当字符串很短时,实例Equals"的性能会稍好一些 - 随着字符串长度的增加,这种差异变得完全无关紧要."

Answer 7

我一直在试图解决一个错误，这是因为我读了本页，并得出结论，在实践中并没有有意义的区别，因此我将在此发布此链接，以防其他人发现它们得到不同的结果等于=且等于。

对象==相等失败，但是.Equals成功。这有意义吗？

string a = "x";
string b = new String(new []{'x'});

Console.WriteLine("x == x " + (a == b));//True
Console.WriteLine("object x == x " + ((object)a == (object)b));//False
Console.WriteLine("x equals x " + (a.Equals(b)));//True
Console.WriteLine("object x equals x " + (((object)a).Equals((object)b)));//True

Answer 8

我想补充说还有另一个不同之处.这与安德鲁发布的内容有关.

它也与在我们的软件中发现错误非常烦人有关.请参阅以下简化示例(我也省略了空检查).

public const int SPECIAL_NUMBER = 213;

public bool IsSpecialNumberEntered(string numberTextBoxTextValue)
{
    return numberTextBoxTextValue.Equals(SPECIAL_NUMBER)
}

这将编译并始终返回false.虽然以下将给出编译错误:

public const int SPECIAL_NUMBER = 213;

public bool IsSpecialNumberEntered(string numberTextBoxTextValue)
{
    return (numberTextBoxTextValue == SPECIAL_NUMBER);
}

我们不得不解决类似的问题,有人比较使用不同类型的枚举Equals.在意识到它是导致错误的原因之前,您将阅读这么多次.特别是如果定义SPECIAL_NUMBER不在问题区域附近.

这就是为什么我真的反对在没有必要的情况下使用Equals.你失去了一点类型安全性.