Si prevede questo comportamento di uguaglianza Tuple C# 4.0?

Question

Sto riscontrando un comportamento diverso tra l'utilizzo di .Equals e == tra due delle nuove istanze di .NET 4.0 di Tuple <>. Se ho effettuato l'override uguale all'oggetto nella tupla <> e chiamo .Equals sulle tuple, verrà chiamato l'override di Equals. Se uso == sulle tuple, l'override di Equals non viene chiamato. È di progettazione e ha senso?

MODIFICA: Da risposte e commenti posso dire che non sono stato chiaro. So che Tuple <> è un tipo di riferimento e che per i tipi di riferimento == controllerà l'identità (ReferenceEquals). Ma, dovrebbe Tuple <> override == per controllare l'uguaglianza degli oggetti che contiene? Per coerenza, probabilmente no.

Per esempio se ho un semplice oggetto

public class NameAndNumber 
{ 
    public int Number { get; set; } 
    public string Name { get; set; } 

    public override bool Equals(object obj) 
    { 
     if (obj is NameAndNumber) 
     { 
      NameAndNumber other = (NameAndNumber)obj; 
      return Number == other.Number && Name == other.Name; 
     } 

     return false; 
    } 
} 

e poi faccio qualcosa di simile:

Tuple<NameAndNumber, NameAndNumber> left = new Tuple<NameAndNumber, NameAndNumber>(
     new NameAndNumber { Name = "one", Number = 1 }, 
     new NameAndNumber { Name = "two", Number = 2 }); 
Tuple<NameAndNumber, NameAndNumber> right = new Tuple<NameAndNumber, NameAndNumber>(
     new NameAndNumber { Name = "one", Number = 1 }, 
     new NameAndNumber { Name = "two", Number = 2 }); 
bool operatorResult = left == right; 
bool equalsResult = left.Equals(right); 
Console.Out.WriteLine("operatorResult = {0} equalsResult = {1}", 
     operatorResult, equalsResult); 

ottengo operatorResult = false equalsResult = true

Dovrei essere in attesa quella?

So che l'implementazione di Equals su NameAndNumber non è "corretta" ma solo codice di esempio semplificato.

Ho anche provato a implementare IEquatable, ==,! = E GetHashCode. Stessi risultati

Answer 1

I risultati che vedete provengono da un design compromise, tuple sono ora condiviso tra F # e C#. Il punto principale è che tutte le tuple sono effettivamente implementate come tipi di riferimento, che non era così ovvio.

La decisione se Tuples debba eseguire controlli di uguaglianza profondi o superficiali è stata spostata su due interfacce: IStructuralComparable, IStructuralEquatable. Nota che quelli 2 ora sono implementati anche dalla classe Array.

Answer 2

Per il tipo di riferimento: == esegue un confronto dell'identità, cioè restituirà true solo se entrambi i riferimenti puntano allo stesso oggetto. Mentre il metodo Equals() dovrebbe eseguire un confronto di valori, cioè restituirà true se i riferimenti puntano a oggetti che sono equivalenti.

Per i tipi di riferimento in cui ha == NON stato sovraccaricato, confronta se due riferimenti si riferiscono allo stesso oggetto

Answer 3

Per impostazione predefinita, l'operatore == test per l'uguaglianza di riferimento, in modo da Sì il risultato che stanno vedendo è previsto.

Vedi Guidelines for Overriding Equals() and Operator == (C# Programming Guide):

In C#, ci sono due diversi tipi di uguaglianza: uguaglianza di riferimento (anche conosciuto come identità) e l'uguaglianza di valore. L'uguaglianza dei valori è generalmente il significato di uguaglianza compreso: significa che due oggetti contengono gli stessi valori . Ad esempio, due numeri interi con valore 2 hanno l'uguaglianza . L'uguaglianza di riferimento significa che non ci sono due oggetti a confronto .

Answer 4

Per impostazione predefinita, == (su una classe) indica l'uguaglianza di riferimento; cioè sono la stessa istanza; cosa restituirebbe object.ReferenceEquals(x,y).

È possibile fornire il proprio == /!= Gli operatori per ottenere il comportamento previsto - e quando si sostituisce Equals è importante per ignorare GetHashCode troppo (altrimenti si interrompe l'utilizzo come chiave - Why is it important to override GetHashCode when Equals method is overriden in C#?):

public static bool operator == (NameAndNumber x, NameAndNumber y) { 
    if (x == null && y == null) return true; 
    if (x == null || y == null) return false; 
    return x.Number == y.Number && x.Name == y.Name; 
    // or if polymorphism is important: return x.Equals(y); 
} 
public static bool operator !=(NameAndNumber x, NameAndNumber y) { 
    return !(x == y); // lazy but works 
} 
public override int GetHashCode() { 
    return (Name == null ? 0 : Name.GetHashCode()) + 
     17 * Number.GetHashCode(); 
}