Betrachten Sie diesen Code:

int age = 25;
short newAge = 25;
Console.WriteLine(age == newAge);  //true
Console.WriteLine(newAge.Equals(age)); //false
Console.ReadLine();

Beide intund shortsind primitive Typen, aber ein Vergleich mit ==return true und ein Vergleich mit Equalsreturn false.

Warum?

Kurze Antwort:

Gleichheit ist kompliziert.

Detaillierte Antwort:

Primitive Typen überschreiben die Basis object.Equals(object)und geben true zurück, wenn das Feld objectdenselben Typ und Wert hat. (Beachten Sie, dass dies auch für nullfähige Typen funktioniert. Nicht null-nullbare Typen können immer mit einer Instanz des zugrunde liegenden Typs verknüpft werden.)

Da newAgees sich um a handelt short, gibt die Equals(object)Methode nur dann true zurück, wenn Sie einen Boxed Short mit demselben Wert übergeben. Sie übergeben eine Box int, daher wird false zurückgegeben.

Im Gegensatz dazu wird der ==Operator so definiert, dass er zwei ints (oder shorts oder longs) nimmt.
Wenn Sie es mit einem intund einem aufrufen short, konvertiert der Compiler implizit das shortin intund vergleicht die resultierenden ints nach Wert.

Andere Möglichkeiten, damit es funktioniert

Primitive Typen haben auch eine eigene Equals()Methode, die denselben Typ akzeptiert.
Wenn Sie schreiben age.Equals(newAge), wählt der Compiler int.Equals(int)die beste Überladung aus und konvertiert implizit shortin int. Es wird dann zurückgegeben true, da diese Methode einfach das ints direkt vergleicht .

shorthat auch eine short.Equals(short)Methode, intkann aber nicht implizit konvertiert werden short, sodass Sie sie nicht aufrufen.

Sie könnten es zwingen, diese Methode mit einer Besetzung aufzurufen:

Console.WriteLine(newAge.Equals((short)age)); // true

Dies wird short.Equals(short)direkt ohne Boxen aufgerufen . Wenn agegrößer als 32767 ist, wird eine Überlaufausnahme ausgelöst.

Sie können die short.Equals(object)Überladung auch aufrufen , aber ein Boxobjekt explizit übergeben, damit es denselben Typ erhält:

Console.WriteLine(newAge.Equals((object)(short)age)); // true

Wie bei der vorherigen Alternative wird dadurch ein Überlauf ausgelöst, wenn er nicht in eine passt short. Im Gegensatz zur vorherigen Lösung wird das shortObjekt in ein Objekt gepackt, wodurch Zeit und Speicher verschwendet werden.

Quellcode:

Hier sind beide Equals()Methoden aus dem eigentlichen Quellcode:

    public override bool Equals(Object obj) {
        if (!(obj is Int16)) {
            return false;
        }
        return m_value == ((Int16)obj).m_value;
    }

    public bool Equals(Int16 obj)
    {
        return m_value == obj;
    }

Weiterführende Literatur:

Siehe Eric Lippert .

Weil es keine Überlastung dafür gibt short.Equals, akzeptiert ein int. Daher heißt dies:

public override bool Equals(object obj)
{
    return obj is short && this == (short)obj;
}

objist kein short.. daher ist es falsch.

Wenn Sie intan short's Equals übergeben, übergeben Sie object:

Dieser Pseudocode läuft also:

return obj is short && this == (short)obj;

Für Werttypen .Equalsmüssen die beiden Objekte vom gleichen Typ sein und denselben Wert haben, während ==nur geprüft wird, ob die beiden Werte gleich sind.

Object.Equals
http://msdn.microsoft.com/en-us/library/bsc2ak47(v=vs.110).aspx

==wird zum Überprüfen einer Gleichheitsbedingung verwendet, kann als Operator (boolescher Operator) betrachtet werden, nur um zwei Dinge zu vergleichen, und hier spielt der Datentyp keine Rolle, da ein Typ-Casting durchgeführt würde, und Equalswird auch zum Überprüfen der Gleichheitsbedingung verwendet In diesem Fall sollten die Datentypen jedoch identisch sein. N Equals ist eine Methode, kein Operator.

Im Folgenden finden Sie ein kleines Beispiel aus dem von Ihnen bereitgestellten Beispiel, das den Unterschied in Kürze verdeutlicht.

int x=1;
short y=1;
x==y;//true
y.Equals(x);//false

Im obigen Beispiel haben X und Y die gleichen Werte, dh 1, und wenn wir verwenden ==, wird true zurückgegeben, da im Fall von ==der Short-Typ vom Compiler in int konvertiert wird und das Ergebnis angegeben wird.

und wenn wir verwenden Equals, wird der Vergleich durchgeführt, aber das Typ-Casting wird nicht vom Compiler durchgeführt, so dass false zurückgegeben wird.

Leute, bitte lasst es mich wissen, wenn ich falsch liege.

In vielen Kontexten, in denen eine Methode oder ein Operatorargument nicht vom erforderlichen Typ ist, versucht der C # -Compiler, eine implizite Typkonvertierung durchzuführen. Wenn der Compiler alle Argumente durch Hinzufügen impliziter Konvertierungen an seine Operatoren und Methoden anpassen kann, erfolgt dies ohne Beanstandung, auch wenn die Ergebnisse in einigen Fällen (insbesondere bei Gleichheitstests!) Überraschend sein können.

Ferner beschreibt jeder Werttyp wie intoder shorttatsächlich sowohl eine Art von Wert als auch eine Art von Objekt (*). Es gibt implizite Konvertierungen, um Werte in andere Arten von Werten zu konvertieren und um jede Art von Wert in die entsprechende Art von Objekt zu konvertieren, aber die verschiedenen Arten von Objekten sind nicht implizit ineinander konvertierbar.

Wenn man den ==Operator verwendet, um a shortund an zu vergleichen int, shortwird das implizit in a konvertiert int. Wenn sein numerischer Wert gleich dem von war int, entspricht der Wert , intmit dem er konvertiert wurde, dem, intmit dem er verglichen wird. Wenn man versucht, die EqualsMethode für den Kurzschluss zu verwenden, um sie mit einer zu vergleichen int, wäre die einzige implizite Konvertierung, die eine Überladung der EqualsMethode befriedigen würde, die Konvertierung in den entsprechenden Objekttyp int. Wenn das shortgefragt wird, ob es mit dem übergebenen Objekt übereinstimmt, wird es feststellen, dass das fragliche Objekt inteher ein als ein ist, shortund daraus schließen, dass es unmöglich gleich sein kann.

Obwohl sich der Compiler nicht darüber beschwert, sollte man im Allgemeinen vermeiden, Dinge zu vergleichen, die nicht vom gleichen Typ sind. Wenn man daran interessiert ist, ob die Konvertierung von Dingen in eine gemeinsame Form das gleiche Ergebnis liefern würde, sollte man eine solche Konvertierung explizit durchführen. Betrachten Sie zum Beispiel

int i = 16777217;
float f = 16777216.0f;

Console.WriteLine("{0}", i==f);

Es gibt drei Möglichkeiten, wie man ein intmit einem vergleichen möchte float. Man möchte vielleicht wissen:

1. Entspricht der nächstmögliche floatWert intdem float?
2. Stimmt die ganze Zahl mit dem floatüberein int?
3. Machen Sie das intund floatrepräsentieren Sie den gleichen numerischen Wert.

Wenn man versucht, ein intund floatdirekt zu vergleichen , beantwortet der kompilierte Code die erste Frage; Ob der Programmierer dies beabsichtigt hat, ist jedoch alles andere als offensichtlich. Wenn Sie den Vergleich auf (float)i == fändern, wird klargestellt, dass die erste Bedeutung beabsichtigt war, oder (double)i == (double)fder Code beantwortet die dritte Frage (und es wird klargestellt, dass dies beabsichtigt ist).

(*) Selbst wenn die C # -Spezifikation einen Wert vom Typ betrachtet, z. System.Int32B. ein Objekt vom Typ System.Int32, wird einer solchen Ansicht die Anforderung widersprochen, dass ein Code auf einer Plattform ausgeführt wird, deren Spezifikation Werte und Objekte als Bewohner verschiedener Universen betrachtet. Wenn Tes sich um einen Referenztyp handelt und xes sich um einen handelt T, Tsollte sich eine Referenz vom Typ beziehen können x. Wenn also eine Variable vvom Typ Int32eine enthält Object, sollte eine Referenz vom Typ Objecteine Referenz voder deren Inhalt enthalten können. Tatsächlich könnte eine Referenz vom Typ Objectauf ein Objekt verweisen, das Daten enthält, die von kopiert wurden v, jedoch nicht auf sich vselbst oder dessen Inhalt. Das würde darauf hindeuten, dass wedervnoch sein Inhalt ist wirklich ein Object.

Equals () ist eine Methode der System.Object- Klassensyntax
: Public virtual bool Equals ()
Empfehlung Wenn wir den Status von zwei Objekten vergleichen möchten, sollten wir die Equals () -Methode verwenden

wie oben angegeben Antworten == Operatoren vergleichen die Werte sind gleich.

Bitte verwechseln Sie nicht ReferenceEqual

Reference Equals ()
Syntax: public static bool ReferenceEquals ()
Bestimmt, ob die angegebene Objektinstanz zur selben Instanz gehört

Was Sie wissen müssen, ist, dass das Tun ==immer eine Methode aufruft. Die Frage ist, ob anrufen ==und Equalsam Ende die gleichen Dinge anrufen / tun.

Bei Referenztypen ==wird immer zuerst geprüft, ob die Referenzen identisch sind ( Object.ReferenceEquals). EqualsAuf der anderen Seite kann überschrieben werden und prüfen, ob einige Werte gleich sind.

BEARBEITEN: Um svick zu beantworten und den Kommentar von SLaks hinzuzufügen, hier ein IL-Code

int i1 = 0x22; // ldc.i4.s ie pushes an int32 on the stack
int i2 = 0x33; // ldc.i4.s 
short s1 = 0x11; // ldc.i4.s (same as for int32)
short s2 = 0x22; // ldc.i4.s 

s1 == i1 // ceq
i1 == s1 // ceq
i1 == i2 // ceq
s1 == s2 // ceq
// no difference between int and short for those 4 cases,
// anyway the shorts are pushed as integers.

i1.Equals(i2) // calls System.Int32.Equals
s1.Equals(s2) // calls System.Int16.Equals
i1.Equals(s1) // calls System.Int32.Equals: s1 is considered as an integer
// - again it was pushed as such on the stack)
s1.Equals(i1) // boxes the int32 then calls System.Int16.Equals
// - int16 has 2 Equals methods: one for in16 and one for Object.
// Casting an int32 into an int16 is not safe, so the Object overload
// must be used instead.

== Im Primitiven

Console.WriteLine(age == newAge);          // true

Im primitiven Vergleich verhalten sich == Operatoren ziemlich offensichtlich. In C # sind viele == Operatorüberladungen verfügbar.

• string == string
• int == int
• uint == uint
• lang == lang
• viel mehr

In diesem Fall erfolgt also keine implizite Konvertierung von int zu shortaber shortzu intist möglich. NewAge wird also in int konvertiert und es erfolgt ein Vergleich, der true zurückgibt, da beide den gleichen Wert haben. Es ist also gleichbedeutend mit:

Console.WriteLine(age == (int)newAge);          // true

.Equals () in Primitive

Console.WriteLine(newAge.Equals(age));         //false

Hier müssen wir sehen, was die Equals () -Methode ist. Wir rufen Equals mit einer kurzen Typvariablen auf. Es gibt also drei Möglichkeiten:

• Gleich (Objekt, Objekt) // statische Methode vom Objekt
• Gleich (Objekt) // virtuelle Methode vom Objekt
• Equals (short) // Implementiert IEquatable.Equals (short)

Der erste Typ ist hier nicht der Fall, da die Anzahl der Argumente unterschiedlich ist und wir nur ein Argument vom Typ int aufrufen. Drittens wird ebenfalls eliminiert, wie oben erwähnt. Eine implizite Umwandlung von int in short ist nicht möglich. Also hier wird der zweite Typ von Equals(object)genannt. Das short.Equals(object)ist:

bool Equals(object z)
{
  return z is short && (short)z == this;
}

Also hier wurde der Zustand getestet z is short die falsch ist, da z ein int ist und daher false zurückgibt.

Hier ist ein ausführlicher Artikel von Eric Lippert