Considera questo codice:

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

Entrambi inte shortsono tipi primitivi, ma un confronto con ==restituisce vero e un confronto con Equalsrestituisce falso.

Perché?

Risposta breve:

L'uguaglianza è complicata.

Risposta dettagliata:

I tipi di primitive sovrascrivono la base object.Equals(object)e restituiscono true se il riquadro objectè dello stesso tipo e valore. (Si noti che funzionerà anche per i tipi nullable; i tipi nullable non null vengono sempre inseriti in un'istanza del tipo sottostante.)

Poiché newAgeè a short, il suo Equals(object)metodo restituisce true solo se si passa un short box con lo stesso valore. Stai passando un box int, quindi restituisce false.

Al contrario, l' ==operatore è definito come prendere due ints (o shorts o longs).
Quando lo chiami con an inte a short, il compilatore convertirà implicitamente shortin inte confronterà le ints risultanti per valore.

Altri modi per farlo funzionare

I tipi primitivi hanno anche il loro Equals()metodo che accetta lo stesso tipo.
Se scrivi age.Equals(newAge), il compilatore selezionerà int.Equals(int)come il miglior sovraccarico e convertirà implicitamente shortin int. Tornerà quindi true, poiché questo metodo confronta semplicemente le ints direttamente.

shortha anche un short.Equals(short)metodo, ma intnon può essere convertito in shortmodo implicito , quindi non lo stai chiamando.

Potresti forzarlo a chiamare questo metodo con un cast:

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

Questo chiamerà short.Equals(short)direttamente, senza boxe. Se ageè maggiore di 32767, genererà un'eccezione di overflow.

Potresti anche chiamare il short.Equals(object)sovraccarico, ma passare esplicitamente un oggetto in scatola in modo che ottenga lo stesso tipo:

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

Come l'alternativa precedente, questo genererà un overflow se non rientra in a short. A differenza della soluzione precedente, inserirà shortun oggetto, sprecando tempo e memoria.

Codice sorgente:

Ecco entrambi i Equals()metodi dal codice sorgente effettivo:

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

Ulteriori letture:

Vedi Eric Lippert .

Perché non c'è sovraccarico per short.Equalsquello accetta un int. Pertanto, questo si chiama:

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

objnon è un short.. quindi è falso.

Quando passi inta short"Equals" passi object:

Quindi viene eseguito questo pseudocodice:

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

Per i tipi di valore, .Equalsrichiede che i due oggetti siano dello stesso tipo e abbiano lo stesso valore, mentre ==verifica solo se i due valori sono uguali.

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

==viene utilizzato per verificare una condizione uguale, può essere considerato un operatore (operatore booleano), solo per confrontare 2 cose e qui il tipo di dati non ha importanza in quanto verrebbe eseguito un casting di tipo e Equalsviene anche utilizzato per verificare la condizione uguale , ma in questo caso i tipi di dati dovrebbero essere uguali. N è un metodo non un operatore.

Di seguito è riportato un piccolo esempio preso da quello che hai fornito e questo chiarirà la differenza in breve.

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

nell'esempio sopra, X e Y hanno gli stessi valori, vale a dire 1, e quando usiamo ==, restituirà vero, come nel caso di ==, il tipo breve viene convertito in int dal compilatore e il risultato è dato.

e quando usiamo Equals, il confronto è fatto, ma il cast del tipo non è fatto dal compilatore, quindi viene restituito falso.

Ragazzi, per favore fatemi sapere se sbaglio.

In molti contesti in cui un argomento di metodo o operatore non è del tipo richiesto, il compilatore C # tenterà di eseguire una conversione di tipo implicita. Se il compilatore può fare in modo che tutti gli argomenti soddisfino i loro operatori e metodi aggiungendo conversioni implicite, lo farà senza lamentarsi, anche se in alcuni casi (specialmente con test di uguaglianza!) I risultati potrebbero essere sorprendenti.

Inoltre, ogni tipo di valore come into shorteffettivamente descrive sia un tipo di valore che un tipo di oggetto (*). Esistono conversioni implicite per convertire i valori in altri tipi di valori e convertire qualsiasi tipo di valore nel tipo di oggetto corrispondente, ma i diversi tipi di oggetti non sono implicitamente convertibili tra loro.

Se si utilizza l' ==operatore per confrontare a shorte an int, il valore shortverrà convertito implicitamente in un int. Se il suo valore numerico era uguale a quello di int, il inta cui è stato convertito sarà uguale inta cui viene confrontato. Se si tenta di utilizzare il Equalsmetodo in breve per confrontarlo con una int, tuttavia, l'unica conversione implicita che soddisferebbe un sovraccarico del Equalsmetodo sarebbe la conversione al tipo di oggetto corrispondente int. Quando shortviene chiesto se corrisponde all'oggetto passato, osserverà che l'oggetto in questione è intpiuttosto che a shorte quindi conclude che non può essere uguale.

In generale, sebbene il compilatore non se ne lamenti, si dovrebbe evitare di confrontare cose che non sono dello stesso tipo; se uno è interessato al fatto che la conversione di cose in una forma comune darebbe lo stesso risultato, si dovrebbe eseguire esplicitamente tale conversione. Considera, ad esempio,

int i = 16777217;
float f = 16777216.0f;

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

Ci sono tre modi in cui si potrebbe voler confrontare un inta float. Uno potrebbe voler sapere:

1. Il floatvalore più vicino possibile alla intcorrispondenza è float?
2. Il numero intero parte della floatpartita è il int?
3. Esegui inte floatrappresentano lo stesso valore numerico.

Se si tenta di confrontare un inte floatdirettamente, il codice compilato risponderà alla prima domanda; se è quello che intendeva il programmatore, tuttavia, sarà tutt'altro che ovvio. Modificando il confronto in (float)i == fmodo da chiarire che era previsto il primo significato, o (double)i == (double)ffarebbe sì che il codice rispondesse alla terza domanda (e chiarire che era quello che era previsto).

(*) Anche se le specifiche C # considerano un valore di tipo System.Int32come ad esempio un oggetto di tipo System.Int32, tale vista è contraddetta dal requisito che un codice venga eseguito su una piattaforma le cui specifiche considerano valori e oggetti come abitanti di universi diversi. Inoltre, se Tè un tipo di riferimento ed xè un T, allora Tdovrebbe essere possibile fare riferimento a un riferimento di tipo x. Pertanto, se una variabile vdi tipo Int32contiene un Object, un riferimento di tipo Objectdovrebbe essere in grado di contenere un riferimento vo il suo contenuto. In effetti, un riferimento di tipo Objectsarebbe in grado di indicare un oggetto contenente dati copiati v, ma non a vse stesso né al suo contenuto. Ciò suggerirebbe che nessuno dei duevné il suo contenuto è davvero un Object.

Equals () è un metodo di System.Object
Sintassi della classe : Bool virtuale pubblico Equals ()
Raccomandazione se vogliamo confrontare lo stato di due oggetti, allora dovremmo usare il metodo Equals ()

come indicato sopra, le risposte == gli operatori confrontano i valori sono gli stessi.

Non confonderti con ReferenceEqual

Reference Equals ()
Sintassi: public static bool ReferenceEquals ()
Determina se l'istanza di oggetti specificata è della stessa istanza

Quello che devi capire è che fare ==finirà sempre per chiamare un metodo. La domanda è se chiamare ==e Equalsfinisce per chiamare / fare le stesse cose.

Con i tipi di riferimento, ==1 ° verificherà sempre se i riferimenti sono uguali ( Object.ReferenceEquals). Equalsd'altra parte può essere ignorato e può verificare se alcuni valori sono uguali.

EDIT: per rispondere a svick e aggiungere il commento di SLaks, ecco un po 'di codice IL

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.

== In Primitivo

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

Nel confronto primitivo == l'operatore si comporta abbastanza ovvio, in C # ci sono molti == sovraccarico dell'operatore disponibili.

• string == string
• int == int
• uint == uint
• long == long
• molti altri

Quindi in questo caso non è possibile alcuna conversione implicita da inta shortma shorta int. Quindi newAge viene convertito in int e si verifica un confronto che restituisce true poiché entrambi hanno lo stesso valore. Quindi è equivalente a:

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

.Equals () in Primitivo

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

Qui dobbiamo vedere cos'è il metodo Equals (), che chiamiamo Equals con una variabile di tipo breve. Quindi ci sono tre possibilità:

• Uguale a (oggetto, oggetto) // metodo statico dall'oggetto
• Uguale a (oggetto) // metodo virtuale dall'oggetto
• Equals (short) // Implementa IEquatable.Equals (short)

Il primo tipo non è un caso qui poiché il numero di argomenti è diverso che chiamiamo con un solo argomento di tipo int. Il terzo è anche eliminato, come indicato sopra, non è possibile la conversione implicita di int in short. Quindi qui Equals(object)viene chiamato il secondo tipo di . Il short.Equals(object)è:

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

Quindi qui la condizione è stata testata, il z is shortche è falso poiché z è un int quindi restituisce falso.

Ecco un articolo dettagliato di Eric Lippert