Differenza C # tra == e Equals ()

Ho una condizione in un'applicazione silverlight che confronta 2 stringhe, per qualche motivo quando lo uso ==restituisce false mentre .Equals()restituisce true .

Ecco il codice:

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

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

Qualche motivo per cui questo sta accadendo?

Quando ==viene utilizzato su un'espressione di tipo object, si risolverà in System.Object.ReferenceEquals.

Equalsè solo un virtualmetodo e si comporta come tale, quindi verrà utilizzata la versione sovrascritta (che, per stringtipo, confronta i contenuti).

Quando si confronta un riferimento a un oggetto con una stringa (anche se il riferimento a un oggetto si riferisce a una stringa), il comportamento speciale ==dell'operatore specifico della classe di stringa viene ignorato.

Normalmente (quando non si tratta di stringhe, cioè), Equalsconfronta i valori , mentre ==confronta i riferimenti agli oggetti . Se due oggetti che stai confrontando si riferiscono alla stessa esatta istanza di un oggetto, entrambi restituiranno true, ma se uno ha lo stesso contenuto e proviene da un'origine diversa (è un'istanza separata con gli stessi dati), solo Equals lo farà ritorna vero. Tuttavia, come notato nei commenti, la stringa è un caso speciale perché sovrascrive l' ==operatore in modo che quando si tratta esclusivamente di riferimenti a stringa (e non a riferimenti a oggetti), vengono confrontati solo i valori anche se sono istanze separate. Il codice seguente illustra le sottili differenze nei comportamenti:

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

L'output è:

True True True
False True True
False False True

==e .Equalsdipendono entrambi dal comportamento definito nel tipo effettivo e dal tipo effettivo nel sito di chiamata. Entrambi sono solo metodi / operatori che possono essere sovrascritti su qualsiasi tipo e dato qualsiasi comportamento l'autore desideri. Nella mia esperienza, trovo che per le persone sia comune implementare .Equalsun oggetto ma trascurare l'implementazione dell'operatore ==. Ciò significa che .Equalsmisurerà effettivamente l'uguaglianza dei valori mentre ==misurerà se sono o meno lo stesso riferimento.

Quando lavoro con un nuovo tipo la cui definizione è in evoluzione o quando scrivo algoritmi generici, trovo che la migliore pratica sia la seguente

• Se voglio confrontare i riferimenti in C #, uso Object.ReferenceEqualsdirettamente (non necessario nel caso generico)
• Se voglio confrontare i valori che uso EqualityComparer<T>.Default

In alcuni casi, quando ritengo che l'uso di ==sia ambiguo, userò esplicitamente Object.Referenceuguali nel codice per rimuovere l'ambiguità.

Eric Lippert ha recentemente pubblicato un post sul blog sul motivo per cui ci sono 2 metodi di uguaglianza nel CLR. Vale la pena leggere

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

== Operatore

1. Se gli operandi sono Tipi di valore e i loro valori sono uguali, restituisce true altrimenti false.
2. Se gli operandi sono Tipi di riferimento con l'eccezione della stringa ed entrambi si riferiscono alla stessa istanza (stesso oggetto), restituisce true else false.
3. Se gli operandi sono di tipo stringa e i loro valori sono uguali, restituisce true else false.

.È uguale a

1. Se gli operandi sono Tipi di riferimento , esegue l' Uguaglianza di riferimento, ovvero se entrambi si riferiscono alla stessa istanza (stesso oggetto), restituisce true altrimenti false.
2. Se gli operandi sono tipi di valore, a differenza dell'operatore == verifica prima il loro tipo e se i loro tipi sono uguali esegue l'operatore == altrimenti restituisce false.

In primo luogo, c'è una differenza. Per i numeri

> 2 == 2.0
True

> 2.Equals(2.0)
False

E per archi

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

> x.Equals(null)
NullReferenceException

In entrambi i casi, ==si comporta in modo più utile di.Equals

Per quanto ho capito, la risposta è semplice:

1. == confronta i riferimenti agli oggetti.
2. .Equals confronta il contenuto dell'oggetto.
3. String i tipi di dati fungono sempre da confronto dei contenuti.

Spero di aver ragione e che abbia risposto alla tua domanda.

Aggiungo che se lanci il tuo oggetto su una stringa, funzionerà correttamente. Questo è il motivo per cui il compilatore ti darà un avviso dicendo:

Possibile confronto di riferimento non intenzionale; per ottenere un confronto di valori, esegui il cast del lato sinistro per digitare "stringa"

Poiché la versione statica del .Equalmetodo non è stata menzionata finora, vorrei aggiungerla qui per riassumere e confrontare le 3 varianti.

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

dove MyStringè una variabile che proviene da qualche altra parte nel codice.

Informazioni di base e per effettuare l'estate:

In Java ==non è necessario utilizzare il confronto per stringhe. Ne parlo nel caso in cui sia necessario utilizzare entrambe le lingue e anche per farti sapere che l'utilizzo ==può anche essere sostituito con qualcosa di meglio in C #.

In C # non c'è alcuna differenza pratica per confrontare le stringhe usando il Metodo 1 o il Metodo 2 purché entrambi siano di tipo stringa. Tuttavia, se uno è nullo, uno è di un altro tipo (come un numero intero) o rappresenta un oggetto con un riferimento diverso, quindi, come mostra la domanda iniziale, potresti riscontrare che il confronto del contenuto per l'uguaglianza potrebbe non restituire ciò che ti aspetti.

Soluzione suggerita:

Poiché l'utilizzo ==non è esattamente uguale all'utilizzo .Equalsquando si confrontano le cose, è possibile utilizzare invece il metodo String.Equals statico . In questo modo, se i due lati non sono dello stesso tipo, si confronteranno comunque i contenuti e se uno è nullo, si eviterà l'eccezione.

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

È un po 'di più da scrivere, ma secondo me è più sicuro da usare.

Ecco alcune informazioni copiate da Microsoft:

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

parametri

a Corda

La prima stringa da confrontare, o null.

b Corda

La seconda stringa da confrontare, o null.

ritorna Boolean

truese il valore di aè uguale al valore di b; in caso contrario, false. Se entrambi ae lo bsono null, il metodo ritorna true.

Proprio come un'aggiunta alle già buone risposte: questo comportamento NON è limitato alle stringhe o al confronto di diversi tipi di numeri. Anche se entrambi gli elementi sono di tipo oggetto dello stesso tipo sottostante. "==" non funzionerà.

La seguente schermata mostra i risultati del confronto tra due valori {int} - object

Sono un po 'confuso qui. Se il tipo di runtime di Content è di tipo string, allora sia == che Equals dovrebbero restituire true. Tuttavia, poiché questo non sembra essere il caso, il tipo di runtime di Content non è una stringa e la chiamata Equals su di esso sta facendo un'uguaglianza referenziale e questo spiega perché Equals ("Energy Attack") fallisce. Tuttavia, nel secondo caso, la decisione su quale sovraccarico == operatore statico dovrebbe essere chiamato viene presa al momento della compilazione e questa decisione sembra essere == (stringa, stringa). questo mi suggerisce che il contenuto fornisce una conversione implicita in stringa.

C'è un'altra dimensione in una risposta precedente di @BlueMonkMN. La dimensione aggiuntiva è che la risposta alla domanda sul titolo di @ Drahcir, come viene affermato, dipende anche da come siamo arrivati ​​al stringvalore. Illustrare:

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

L'output è:

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

Aggiungendo un altro punto alla risposta.

.EqualsTo() Il metodo ti fornisce la possibilità di confrontare con cultura e maiuscole e minuscole.

Il ==token in C # viene utilizzato per due diversi operatori di controllo dell'uguaglianza. Quando il compilatore incontra quel token, verificherà se uno dei tipi confrontati ha implementato un sovraccarico operatore-uguaglianza per i tipi di combinazione specifici da confrontare (*) o per una combinazione di tipi in cui entrambi i tipi possono essere convertiti. Se il compilatore rileva un tale sovraccarico, lo utilizzerà. Altrimenti, se i due tipi sono entrambi tipi di riferimento e non sono classi non correlate (o possono essere un'interfaccia o possono essere classi correlate), il compilatore considererà ==un operatore di confronto di riferimento. Se nessuna delle due condizioni si applica, la compilazione fallirà.

Si noti che alcune altre lingue usano token separati per i due operatori di controllo dell'uguaglianza. In VB.NET, ad esempio, il =token viene utilizzato all'interno delle espressioni esclusivamente per l'operatore di verifica dell'uguaglianza sovraccaricabile e Isviene utilizzato come operatore di test di riferimento o test null. L'uso =da parte di un tipo che non prevale sull'operatore di verifica dell'uguaglianza fallirà, così come il tentativo di utilizzare Isper scopi diversi dalla verifica dell'uguaglianza o della nullità di riferimento.

(*) I tipi generalmente sovraccaricano l'uguaglianza solo per il confronto con se stessi, ma può essere utile per i tipi sovraccaricare l'operatore di uguaglianza per il confronto con altri tipi particolari; per esempio, intavrebbe potuto (e IMHO avrebbe dovuto, ma non avrebbe), definito un operatore di uguaglianza per il confronto float, in modo che 16777217 non si riferisse a pari a 16777216f. Così com'è, poiché non viene definito alcun operatore di questo tipo, C # promuoverà il intto float, arrotondandolo a 16777216f prima che l'operatore di controllo dell'uguaglianza lo veda; quell'operatore vede quindi due numeri uguali in virgola mobile e li riporta come uguali, ignari dell'arrotondamento che ha avuto luogo.

Risposte ed esempi davvero fantastici!

Vorrei solo aggiungere la differenza fondamentale tra i due,

Operatori come ==non sono polimorfici, mentre lo Equalsè

Con questo concetto in mente, se elaborate qualche esempio (osservando il tipo di riferimento della mano sinistra e della destra e verificando / sapendo se il tipo ha effettivamente == l'operatore è sovraccarico e gli uguali vengono sostituiti) siete sicuri di ottenere la risposta giusta .

Quando creiamo un oggetto, ci sono due parti dell'oggetto: uno è il contenuto e l'altro è riferimento a quel contenuto. ==confronta sia contenuto che riferimento; equals()confronta solo i contenuti

http://www.codeproject.com/Articles/584128/What-is-the-difference-between-equalsequals-and-Eq

==

L'operatore == può essere utilizzato per confrontare due variabili di qualsiasi tipo e confronta semplicemente i bit .

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

Nota: ci sono più zeri sul lato sinistro dell'int ma non ci interessa a questo.

int a (00000011) == byte b (00000011)

Ricorda che l'operatore == si preoccupa solo del modello dei bit nella variabile.

Utilizzare == Se due riferimenti (primitivi) si riferiscono allo stesso oggetto nell'heap.

Le regole sono le stesse indipendentemente dal fatto che la variabile sia un riferimento o una primitiva.

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 è vero a == b è falso

il modello di bit è lo stesso per a e c, quindi sono uguali usando ==.

Pari():

Usa il metodo equals () per vedere se due oggetti diversi sono uguali .

Come due diversi oggetti String che rappresentano entrambi i personaggi in "Jane"

L'unica differenza tra Equal e == sta nel confronto del tipo di oggetto. in altri casi, come tipi di riferimento e tipi di valore, sono quasi uguali (entrambi sono uguaglianza bit-bit o entrambi sono uguaglianza di riferimento).

oggetto: uguale: uguaglianza bit = = uguaglianza di riferimento

string: (equals e == sono gli stessi per string, ma se una delle string cambia in oggetto, il risultato del confronto sarà diverso) Equals: uguaglianza bit-bit = =: uguaglianza bit-saggio

Vedi qui per ulteriori spiegazioni.