C # Unterschied zwischen == und Equals ()

Ich habe eine Bedingung in einer Silverlight - Anwendung , die zwei Strings vergleicht, aus irgendeinem Grund , wenn ich ==es wieder falsch während .Equals()kehrt wahr .

Hier ist der Code:

if (((ListBoxItem)lstBaseMenu.SelectedItem).Content.Equals("Energy Attack"))
{
    // Execute code
}

if (((ListBoxItem)lstBaseMenu.SelectedItem).Content == "Energy Attack")
{
    // Execute code
}

Gibt es einen Grund, warum dies geschieht?

Wenn ==es für einen Ausdruck vom Typ verwendet wird object, wird es in aufgelöst System.Object.ReferenceEquals.

Equalsist nur eine virtualMethode und verhält sich so, daher wird die überschriebene Version verwendet (die für den stringTyp den Inhalt vergleicht).

Beim Vergleichen einer Objektreferenz mit einer Zeichenfolge (auch wenn sich die Objektreferenz auf eine Zeichenfolge bezieht) wird das spezielle Verhalten des ==für die Zeichenfolgenklasse spezifischen Operators ignoriert.

Normalerweise (wenn es sich nicht um Zeichenfolgen handelt) werden WerteEquals verglichen , während Objektreferenzen verglichen werden . Wenn sich zwei Objekte, die Sie vergleichen, auf dieselbe exakte Instanz eines Objekts beziehen, geben beide true zurück. Wenn jedoch eines denselben Inhalt hat und aus einer anderen Quelle stammt (eine separate Instanz mit denselben Daten), wird nur Equals verwendet return true. Wie in den Kommentaren erwähnt, ist die Zeichenfolge jedoch ein Sonderfall, da sie den Operator überschreibt , sodass beim reinen Umgang mit Zeichenfolgenreferenzen (und nicht mit Objektreferenzen) nur die Werte verglichen werden, selbst wenn es sich um separate Instanzen handelt. Der folgende Code veranschaulicht die subtilen Unterschiede im Verhalten:====

string s1 = "test";
string s2 = "test";
string s3 = "test1".Substring(0, 4);
object s4 = s3;
Console.WriteLine("{0} {1} {2}", object.ReferenceEquals(s1, s2), s1 == s2, s1.Equals(s2));
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));

Die Ausgabe ist:

True True True
False True True
False False True

==und .Equalssind sowohl abhängig vom im tatsächlichen Typ definierten Verhalten als auch vom tatsächlichen Typ am Anrufort. Beides sind nur Methoden / Operatoren, die für jeden Typ und jedes vom Autor gewünschte Verhalten überschrieben werden können. Nach meiner Erfahrung ist es üblich, dass Benutzer .Equalsein Objekt implementieren, den Operator jedoch nicht implementieren ==. Dies bedeutet, dass .Equalstatsächlich die Gleichheit der Werte ==gemessen wird, während gemessen wird, ob es sich um dieselbe Referenz handelt oder nicht.

Wenn ich mit einem neuen Typ arbeite, dessen Definition im Fluss ist, oder generische Algorithmen schreibe, finde ich die folgende Best Practice

• Wenn ich Referenzen in C # vergleichen möchte, verwende ich Object.ReferenceEqualsdirekt (im generischen Fall nicht erforderlich)
• Wenn ich Werte vergleichen möchte, verwende ich EqualityComparer<T>.Default

In einigen Fällen, wenn ich der Meinung bin, dass die Verwendung von nicht ==eindeutig ist, verwende ich explizit Object.ReferenceGleichheiten im Code, um die Mehrdeutigkeit zu beseitigen.

Eric Lippert hat kürzlich einen Blog-Beitrag zum Thema verfasst, warum es in der CLR zwei Methoden der Gleichstellung gibt. Es ist die Lektüre wert

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

== Operator

1. Wenn Operanden Werttypen und deren Werte sind gleich sind, gibt es wahr , sonst falsch.
2. Wenn Operanden Referenztypen mit Ausnahme der Zeichenfolge sind und beide auf dieselbe Instanz verweisen (dasselbe Objekt) , wird true zurückgegeben, andernfalls false.
3. Wenn Operanden vom Typ String sind und ihre Werte gleich sind, wird true zurückgegeben, andernfalls false.

Gleichungen

1. Wenn Operanden Referenztypen sind , wird die Referenzgleichheit ausgeführt. Wenn sich beide auf dieselbe Instanz (dasselbe Objekt) beziehen , wird true zurückgegeben, andernfalls false.
2. Wenn Operanden sind Werttypen dann anders als Operator == es prüft , ob ihre Art erste und wenn ihre Typen sind die gleichen sie führt Operator == sonst falsch er zurückkehrt.

Erstens gibt es einen Unterschied. Für Zahlen

> 2 == 2.0
True

> 2.Equals(2.0)
False

Und für Streicher

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

> x.Equals(null)
NullReferenceException

In beiden Fällen ==verhält sich nützlicher als.Equals

Soweit ich es verstehe, ist die Antwort einfach:

1. == vergleicht Objektreferenzen.
2. .Equals vergleicht den Objektinhalt.
3. String Datentypen verhalten sich immer wie ein Inhaltsvergleich.

Ich hoffe ich bin richtig und es hat deine Frage beantwortet.

Ich würde hinzufügen, dass wenn Sie Ihr Objekt in eine Zeichenfolge umwandeln, es korrekt funktioniert. Aus diesem Grund gibt der Compiler eine Warnung aus:

Möglicher unbeabsichtigter Referenzvergleich; Um einen Wertevergleich zu erhalten, geben Sie auf der linken Seite 'string' ein.

Da die statische Version der .EqualMethode bisher nicht erwähnt wurde, möchte ich diese hier hinzufügen, um die 3 Variationen zusammenzufassen und zu vergleichen.

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

wo MyString ist eine Variable, die von irgendwo anders im Code kommt.

Hintergrundinfo und zum Sommer:

In Java sollte die Verwendung ==zum Vergleichen von Zeichenfolgen nicht verwendet werden. Ich erwähne dies für den Fall, dass Sie beide Sprachen verwenden müssen und dass Sie dies auch wissen müssen== in C # auch durch etwas Besseres ersetzt kann.

In C # gibt es keinen praktischen Unterschied für den Vergleich von Zeichenfolgen mit Methode 1 oder Methode 2, solange beide vom Typ Zeichenfolge sind. Wenn jedoch einer null ist, einer von einem anderen Typ ist (wie eine Ganzzahl) oder einer ein Objekt darstellt, das eine andere Referenz hat, kann es sein, dass der Vergleich des Inhalts auf Gleichheit möglicherweise nicht das zurückgibt, was die erste Frage zeigt du erwartest.

Vorgeschlagene Lösung:

Da die Verwendung ==nicht genau mit der Verwendung .Equalsbeim Vergleichen von Dingen identisch ist , können Sie stattdessen die statische String.Equals- Methode verwenden. Auf diese Weise vergleichen Sie den Inhalt, wenn die beiden Seiten nicht vom selben Typ sind, und wenn eine Null ist, vermeiden Sie die Ausnahme.

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

Es ist etwas mehr zu schreiben, aber meiner Meinung nach sicherer zu verwenden.

Hier sind einige Informationen, die von Microsoft kopiert wurden:

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

Parameter

a String

Die erste zu vergleichende Zeichenfolge, oder null.

b String

Die zweite zu vergleichende Zeichenfolge oder null .

Kehrt zurück Boolean

truewenn der Wert von ader gleiche ist wie der Wert von b; sonst , false. Wenn beides aund bsind null, gibt die Methode zurück true.

Nur als Ergänzung zu den bereits guten Antworten: Dieses Verhalten ist NICHT auf Strings oder den Vergleich verschiedener Zahlentypen beschränkt. Auch wenn beide Elemente vom Typ Objekt desselben zugrunde liegenden Typs sind. "==" wird nicht funktionieren.

Der folgende Screenshot zeigt die Ergebnisse des Vergleichs zweier Objektwerte {int}

Ich bin hier etwas verwirrt. Wenn der Laufzeittyp von Content vom Typ string ist, sollten sowohl == als auch Equals true zurückgeben. Da dies jedoch nicht der Fall zu sein scheint, ist der Inhaltstyp zur Laufzeit keine Zeichenfolge, und das Aufrufen von Equals führt zu einer referenziellen Gleichheit. Dies erklärt, warum Equals ("Energy Attack") fehlschlägt. Im zweiten Fall wird jedoch zur Kompilierungszeit die Entscheidung getroffen, welcher überladene == statische Operator aufgerufen werden soll, und diese Entscheidung scheint == (Zeichenfolge, Zeichenfolge) zu sein. Dies legt für mich nahe, dass Content eine implizite Konvertierung in einen String bietet.

Eine frühere Antwort von @BlueMonkMN hat eine andere Dimension. Die zusätzliche Dimension ist, dass die Antwort auf die Titelfrage von @ Drahcir, wie angegeben, auch davon abhängt, wie wir zu dem stringWert gekommen sind. Um zu zeigen:

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

Die Ausgabe ist:

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

Hinzufügen eines weiteren Punktes zur Antwort.

.EqualsTo() Methode bietet Ihnen die Möglichkeit, mit Kultur und Groß- und Kleinschreibung zu vergleichen.

Das ==Token in C # wird für zwei verschiedene Gleichheitsprüfungsoperatoren verwendet. Wenn der Compiler auf dieses Token stößt, prüft er, ob einer der verglichenen Typen eine Überladung des Gleichheitsoperators für die zu vergleichenden spezifischen Kombinationstypen (*) oder für eine Kombination von Typen implementiert hat, in die beide Typen konvertiert werden können. Wenn der Compiler eine solche Überlastung feststellt, wird er diese verwenden. Andernfalls betrachtet der Compiler ==einen Referenzvergleichsoperator , wenn die beiden Typen beide Referenztypen sind und keine nicht verwandten Klassen sind (entweder eine Schnittstelle oder verwandte Klassen) . Wenn keine der beiden Bedingungen zutrifft, schlägt die Kompilierung fehl.

Beachten Sie, dass einige andere Sprachen separate Token für die beiden Gleichheitsprüfungsoperatoren verwenden. In VB.NET wird das =Token beispielsweise in Ausdrücken ausschließlich für den überladbaren Gleichheitsprüfungsoperator Isverwendet und als Referenztest- oder Nulltestoperator verwendet. Eine Verwendung =für einen Typ, der den Gleichheitsprüfungsoperator nicht überschreibt, schlägt fehl, ebenso wie der Versuch, sie Isfür einen anderen Zweck als das Testen der Referenzgleichheit oder der Nichtigkeit zu verwenden.

(*) Typen überladen im Allgemeinen nur die Gleichheit zum Vergleich mit sich selbst, aber es kann für Typen nützlich sein, den Gleichheitsoperator zum Vergleich mit anderen bestimmten Typen zu überladen. hätte zum Beispiel inteinen Gleichheitsoperator zum Vergleich mit definieren können (und IMHO hätte dies tun sollen, aber nicht) float, so dass sich 16777217 nicht gleich 16777216f melden würde. Wie es ist, da eine solche Operator definiert ist, wird C # die Förderung intauf float, um es zu 16777216f Runden vor dem Gleichheitsprüfung Bediener es sieht; Dieser Operator sieht dann zwei gleiche Gleitkommazahlen und meldet sie als gleich, ohne die Rundung zu kennen, die stattgefunden hat.

Wirklich tolle Antworten und Beispiele!

Ich möchte nur den grundlegenden Unterschied zwischen den beiden hinzufügen,

Operatoren wie ==sind nicht polymorph, während es Equalsist

Unter Berücksichtigung dieses Konzepts erhalten Sie mit Sicherheit die richtige Antwort, wenn Sie ein Beispiel ausarbeiten (indem Sie den Referenztyp für die linke und rechte Hand betrachten und prüfen / wissen, ob der Typ tatsächlich == Operator überladen und Equals überschrieben hat) .

Wenn wir ein Objekt erstellen, besteht das Objekt aus zwei Teilen: dem Inhalt und dem Verweis auf diesen Inhalt. ==vergleicht sowohl Inhalt als auch Referenz; equals()vergleicht nur Inhalte

http://www.codeproject.com/Articles/584128/Was ist der Unterschied zwischen den gleichen Folgen und Gl

==

Der Operator == kann verwendet werden, um zwei Variablen beliebiger Art zu vergleichen, und vergleicht einfach die Bits .

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

Hinweis: Auf der linken Seite des Int befinden sich weitere Nullen, aber das interessiert uns hier nicht.

int a (00000011) == Byte b (00000011)

Denken Sie daran, dass der Operator == sich nur um das Muster der Bits in der Variablen kümmert.

Use == Wenn zwei Referenzen (Grundelemente) auf dasselbe Objekt auf dem Heap verweisen.

Die Regeln sind gleich, unabhängig davon, ob die Variable eine Referenz oder ein Grundelement ist.

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 ist wahr a == b ist falsch

Das Bitmuster ist für a und c gleich, daher sind sie mit == gleich.

Gleich():

Verwenden Sie die Methode equals (), um festzustellen, ob zwei verschiedene Objekte gleich sind .

Zum Beispiel zwei verschiedene String-Objekte, die beide die Zeichen in "Jane" darstellen.

Der einzige Unterschied zwischen Equal und == besteht im Objekttypvergleich. In anderen Fällen, z. B. bei Referenztypen und Werttypen, sind sie nahezu gleich (entweder sind beide bitweise Gleichheit oder beide sind Referenzgleichheit).

Objekt: Gleich: bitweise Gleichheit ==: Referenzgleichheit

Zeichenfolge: (gleich und == sind für Zeichenfolge gleich, aber wenn eine der Zeichenfolgen in Objekt geändert wird, ist das Vergleichsergebnis unterschiedlich.) Gleich: bitweise Gleichheit ==: bitweise Gleichheit

Sehen Sie hier für weitere Erklärung.