Warum sollten Sie String.Equals statt == verwenden?

Question

Ich wurde kürzlich in eine große Codebasis eingeführt und bemerkte, dass alle String-Vergleiche mit String.Equals() anstelle von ==

Was denken Sie, was ist der Grund dafür?

Answer 1

Es ist sehr wahrscheinlich, dass ein großer Teil der Entwicklerbasis aus einem Java-Hintergrund kommt, in dem die Verwendung von == zum Vergleichen von Zeichenketten ist falsch und funktioniert nicht.

In C# gibt es keinen (praktischen) Unterschied (für Strings), solange sie als String typisiert sind.

Wenn sie eingegeben werden als object o T dann sehen Sie andere Antworten hier, die über generische Methoden oder Operatorüberladung sprechen, wie dort Sie definitiv die Equals-Methode verwenden möchten.

Answer 2

Es gibt einen praktischen Unterschied zwischen string.Equals y ==

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

Uhr hinzufügen

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

Jetzt schauen Sie sich {1#} y {5#}

obj , str2 , str4 y obj2 Referenzen sind gleich.

obj y obj2 sont object type und andere sind string type

Schlussfolgerung :

1. com1 Ergebnis = (obj == str2);// true
   • vergleicht object y string führt also eine Referenzgleichheitsprüfung durch
   • obj und str2 zeigen auf dieselbe Referenz, so dass das Ergebnis wahr ist
2. com2 Ergebnis = (obj == str3);// falsch
   • vergleicht object y string führt also eine Referenzgleichheitsprüfung durch
   • obj und str3 verweisen auf unterschiedliche Referenzen, so dass das Ergebnis falsch ist
3. com3 Ergebnis = (obj == str4);// true
   • vergleicht object y string führt also eine Referenzgleichheitsprüfung durch
   • obj und str4 verweisen auf dieselbe Referenz, so dass das Ergebnis wahr ist
4. com4 Ergebnis = (str2 == str3);// wahr
   • vergleicht string y string führt also eine Überprüfung der Zeichenkettenwerte durch
   • str2 und str3 sind beide "String", also ist das Ergebnis wahr
5. com5 Ergebnis = (str2 == str4);// wahr
   • vergleicht string y string führt also eine Überprüfung der Zeichenkettenwerte durch
   • str2 und str4 sind beide "String", also ist das Ergebnis wahr
6. com6 Ergebnis = (str3 == str4);// wahr
   • vergleicht string y string führt also eine Überprüfung der Zeichenkettenwerte durch
   • str3 und str4 sind beide "String", also ist das Ergebnis wahr
7. com7 Ergebnis = (obj == obj2);// falsch - vergleicht object y object s - obj und obj2 zeigen auf unterschiedliche Referenzen, daher ist das Ergebnis falsch

Answer 3

Es gibt eine subtiler, aber sehr wichtiger Unterschied zwischen == und den String.Equals-Methoden:

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);
        }
    }
}

Erzeugt diese Ausgabe:

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

Sie sehen, dass der ==-Operator Folgendes zurückgibt falsch zu zwei offensichtlich gleichen Zeichenfolgen. Warum? Weil der ==-Operator, der in der generischen Methode verwendet wird, so aufgelöst wird, dass er die op_equal-Methode ist, wie sie von System.Object definiert wird (die einzige Garantie für T, die die Methode zur Kompilierungszeit hat), was bedeutet, dass es sich um Referenzgleichheit statt um Wertgleichheit handelt.

Wenn zwei Werte explizit als System.String typisiert sind, dann hat == eine Wertgleichheitssemantik, weil der Compiler das == in System.String.op_equal anstelle von System.Object.op_equal auflöst.

Um auf Nummer sicher zu gehen, verwende ich stattdessen fast immer String.Equals, damit ich immer die gewünschte Semantik der Wertgleichheit erhalte.

Und um NullReferenceExceptions zu vermeiden, wenn einer der Werte null ist, verwende ich immer die statisch String.Equals Methode:

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

Answer 4

String.Equals bietet Überladungen, um Gehäuse und kulturspezifische Vergleiche zu behandeln. Wenn Ihr Code diese nicht nutzt, sind die Entwickler vielleicht nur an Java gewöhnt, wo Sie (wie Matthew sagt) die Methode .Equals verwenden müssen, um Inhaltsvergleiche durchzuführen.

Answer 5

Beide Methoden haben die gleiche Wirkung funktionell - sie vergleichen Werte .
Wie auf MSDN geschrieben wird:

• Über String.Equals Methode - Bestimmt, ob diese Instanz und ein anderes angegebenes String-Objekt den gleichen Wert haben. ( http://msdn.microsoft.com/en-us/library/858x0yyx.aspx )
• Über == - Obwohl string ein Referenztyp ist, sind die Gleichheitsoperatoren ( == und != ) sind definiert, um die Werte von String-Objekten zu vergleichen, nicht Referenzen. Dies macht das Testen auf String-Gleichheit intuitiver. ( http://msdn.microsoft.com/en-en/library/362314fe.aspx )

Wenn aber eine Ihrer String-Instanzen null ist, funktionieren diese Methoden anders:

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");