- Il metodo ReferenceEquals verifica le uguaglianze per riferimento
- Il metodo Equals verifica le uguaglianze per valore
- l’operatore “==” a volte per riferimento e a volte per valore.
Ecco qualche esempio:
Se dichiariamo a e b in questo modo:
System.Object a = new System.Object();
System.Object b = a;
a e b sono riferimento allo stesso oggetto. Per avere la prova sul campo basta eseguire questo codice:
class Program
{
static void Main(string[] args)
{
ObjectClass o1 = new ObjectClass();
ObjectClass o2 = o1;
o1.Value = 3;
Console.WriteLine("o1: {0}", o1.Value);
Console.WriteLine("o2: {0}", o2.Value);
o2.Value = 5;
Console.WriteLine("o1: {0}", o1.Value);
Console.WriteLine("o2: {0}", o2.Value);</code>
Console.WriteLine("ReferenceEquals: {0}", System.Object.ReferenceEquals(o1, o2));
}
class ObjectClass
{
private int value;</code>
public int Value
{
get { return this.value; }
set { this.value = value; }
}
}
}Il risultato è:
o1: 3
o2: 3
o1: 5
o2: 5
ReferenceEquals: True
Equals: True
==: True
quindi modificare uno dei due oggetti significa modificare anche l’altro. Il metodo System.Object.ReferenceEquals verifica appunto l’uguaglianza per riferimento di due oggetti.
Se invece li dichiariamo così:
ObjectClass o1 = new ObjectClass();
ObjectClass o2 = new ObjectClass();
o1.Value = 3;
o2.Value = 3;
Console.WriteLine("ReferenceEquals: {0}", System.Object.ReferenceEquals(o1, o2));
Console.WriteLine("Equals: {0}", System.Object.Equals(o1, o2));
Console.WriteLine("==: {0}", o1 == o2);
il risultato è:
ReferenceEquals: False
Equals: False
==: False
- ReferenceEquals è False perche o1 e o2 sono due oggetti separati, che nulla hanno in comune se non il valore uguale.
- Equals è False perchè sto confrontando due oggetti che ho creato io, e in cui non ho specificato nessun ovverride per il metodo Equals.
- == è false perchè in questo caso si comporta come ReferenceEquals
Un esempio interessante è questo, sulle stringhe:
String s1 = "pippo";
String s2 = "pippo";
Console.WriteLine("Risultato ReferenceEquals: {0}", System.Object.ReferenceEquals(s1, s2));
Console.WriteLine("Risultato Equals: {0}", System.Object.Equals(s1, s2));
Console.WriteLine("Risultato ==: {0}", s1 == s2);
il risultato è:
Risultato ReferenceEquals: True
Risultato Equals: True
Risultato ==: True
- ReferenceEquals restituisce True perche s1 e s2 sono riferimento allo stesso oggetto. Così funziona c# quando si dichiarano più stringhe con lo stesso valore.
- Equals resituisce True perchè sto confrontando un’oggetto con se stesso
- == restituisce True perchè in questo caso si comporta come Equals
Invece:
String s1 = "pippo";
String s2 = String.Copy(s1);
Console.WriteLine("Risultato ReferenceEquals: {0}", System.Object.ReferenceEquals(s1, s2));
Console.WriteLine("Risultato Equals: {0}", System.Object.Equals(s1, s2));
Console.WriteLine("Risultato ==: {0}", s1 == s2);
(il metodo String.Copy crea una nuova istanza con valore uguale a quella in input)
genera questo risultato:
Risultato ReferenceEquals: False
Risultato Equals: True
Risultato ==: True
- ReferenceEquals restituisce false, perchè s1 e s2 non puntano allo stesso oggetto
- Equals restituisce True, perchè s1 e s2 hanno lo stesso valore
- == restituisce True perchè in questo caso si comporta come Equals
L’operatore ==, al contrario del Java, può essere usato per il confronto fra stringhe. Ma vediamo cosa succede se facciamo un downgrade di String a Object:
String s1 = "pippo";
String s2 = String.Copy(s1);
Console.WriteLine("Risultato ReferenceEquals: {0}", System.Object.ReferenceEquals(s1, s2));
Console.WriteLine("Risultato ReferenceEquals: {0}", System.Object.ReferenceEquals((Object)s1, (Object)s2));
Console.WriteLine("Risultato Equals: {0}", System.Object.Equals(s1, s2));
Console.WriteLine("Risultato Equals: {0}", System.Object.Equals((Object)s1, (Object)s2));
Console.WriteLine("Risultato ==: {0}", s1 == s2);
Console.WriteLine("Risultato ==: {0}", (Object)s1 == (Object)s2);
Il risultato è:
Risultato ReferenceEquals: False
Risultato ReferenceEquals: False
Risultato Equals: True
Risultato Equals: True
Risultato ==: True
Risultato ==: False
Il suo comportamento è definito dall’msdn di mamma Microsoft:
For predefined value types, the equality operator (==) returns true if the values of its operands are equal, false otherwise. For reference types other than string, == returns true if its two operands refer to the same object. For the string type, == compares the values of the strings.
Ovvero: l’uguaglianza è verificata per valore se è verificata fra tipi predefiniti e stringhe, in tutti gli altri casi è per riferimento.
