C # cosa fa l'operatore == in dettaglio?

Question

in c # cosa succede esattamente in background quando si fa un confronto con " == " operatore su due oggetti? confronta solo gli indirizzi? o fa qualcosa come Equals () o CompareTo ()?

PS: che dire del " == " operatore a java? si comporta allo stesso modo?

Answer 1

Per quanto ne so:

• confronta i tipi di valore per valore (uguaglianza)
• confronta i tipi di riferimento per riferimento (identità)
• tranne se l'operatore == è sovraccarico, quindi lo chiama.

Equals è implementato nell'oggetto e può anche essere ignorato. L'implementazione predefinita in Object esegue un confronto di riferimento per i tipi di riferimento. Quindi, per impostazione predefinita, Equals e == fanno lo stesso.

Penso che in Java non sia possibile sovraccaricare l'operatore ==. Ma la mia conoscenza di Java è piuttosto obsoleta.

Modifica Si noti che l'operatore == è un metodo statico. È associato al momento della compilazione, in base ai tipi di variabili o campi. Equals è un metodo virtuale che si trova in fase di runtime, basato sui tipi di runtime effettivi.

Answer 2

Come estensione di Risposta eccellente di Stefan - un'altra eccezione è se gli operandi implicano Nullable<T> - nel qual caso " revocato " si applicano gli operatori (14.2.7 in ECMA 334v4):

  

Per gli operatori di uguaglianza   ==! =

     

esiste una forma rialzata di un operatore se i tipi di operando sono entrambi   tipi di valore non annullabili e se il   il tipo di risultato è bool. La forma sollevata   è costruito aggiungendo un singolo?   modificatore per ciascun tipo di operando. Il   l'operatore sollevato considera due null   valori uguali e un valore null disuguale   a qualsiasi valore non nullo. Se entrambi   gli operandi sono non nulli, l'elevato   l'operatore disimballa gli operandi e   applica l'operatore sottostante a   produce il risultato bool.

Ciò significa: perché esiste un operatore di uguaglianza tra (diciamo):

int i = ..., j = ...;
bool eq = i == j;

Quindi esiste un operatore implicito del modulo (sebbene fatto diversamente):

int? i = ..., j = ...;
bool eq;
if(i.HasValue) {
    if(j.HasValue) { // both have values; compare
       eq = i.GetValueOrDefault() == j.GetValueOrDefault();
    } else { // one null; always false
       eq = false;
    }
} else { // true if both null, else false
    eq = !j.HasValue;
}

Answer 3

Da MSDN :

  

Per tipi di valore predefiniti, il   l'operatore di uguaglianza (==) restituisce vero se   i valori dei suoi operandi sono uguali,   falso altrimenti. Per i tipi di riferimento   diverso da stringa, == restituisce vero se   i suoi due operandi si riferiscono allo stesso   oggetto. Per il tipo di stringa, ==   confronta i valori delle stringhe.

Answer 4

No ... l'operatore == non si comporta sempre allo stesso modo in Java e in c #.

Ad esempio con Stringhe; Java == confronta i riferimenti degli oggetti stringa ... (se usi tipi primitve, == in java confronta i valori). Ecco perché

// returns FALSE in JAVA
(new String("test") == "test") 

non restituirà true in java ...

In C #, al contrario, l'operatore == si comporta diversamente sulle stringhe. Ad esempio, restituirà true nel seguente caso:

// returns TRUE in C#
(new String("test".ToCharArray()) == "test") 

Answer 5

Ciò che fa dipende dal contesto.

http://en.csharp-online.net/ECMA -334: _14.9_Relational_and_type-testing_operators

Answer 6

Il comportamento dell'operatore == dipende da come è stata dichiarata la variabile a cui la si sta applicando (non sulla classe dell'oggetto, aggiungerò un esempio).

Per i tipi di valore confronterà i loro valori.

Per i tipi di riferimento a == b restituisce vero se a è lo stesso oggetto di b, a meno che l'operatore == non sia stato sovraccaricato. Non sovrascritto come altri hanno affermato, non è possibile ignorare gli operatori in c # perché non sono virtuali.

            oggetto obj_a, obj_b;             string str_a, str_b;

        str_a = "ABC";
        str_b = new string("ABC".ToCharArray());
        obj_a = str_a;
        obj_b = str_b;

        Console.WriteLine("str_a == str_b = {0}", str_a == str_b); // in string == operator is overloaded
        Console.WriteLine("str_a.Equals(str_b) = {0}", str_a.Equals(str_b)); // string overrides Object.Euqals
        Console.WriteLine("obj_a == obj_b = {0}", obj_a == obj_b); // in object == operator is not overloaded
        Console.WriteLine("obj_a.Equals(obj_b) = {0}", obj_a.Equals(obj_b)); // Object.Equesl is virtual and overridden method from string will be executed.
        Console.ReadKey();

L'output di quel programma è

str_a == str_b = True
str_a.Equals(str_b) = True
obj_a == obj_b = False
obj_a.Equals(obj_b) = True