¿Se espera que este sea el comportamiento de igualdad de tuplas de C# 4.0?

Question

Estoy viendo un comportamiento diferente entre usar .Equals y == entre dos de las nuevas instancias Tuple <> .NET 4.0. Si he reemplazado Equals en el objeto en el Tuple <> y llamo .Equals en las Tuplas, se invocará la anulación de Equals. Si utilizo == en las Tuplas, no se llama a la anulación de Equals. ¿Es eso por diseño y tiene sentido?

EDIT: De las respuestas y los comentarios puedo decir que no estoy siendo claro. Sé que Tuple <> es un tipo de referencia y que para los tipos de referencia == comprobará la identidad (ReferenceEquals). Pero, ¿debería Tuple <> anular == para verificar la igualdad de los objetos que contiene? Por consistencia, probablemente no.

Por ejemplo si tengo un objeto simple

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

y luego hago algo como esto:

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

consigo operatorResult = false equalsResult = true

¿Debo estar esperando ¿ese?

Sé que la implementación de Equals en NameAndNumber no es "correcta", simplemente se trata de un código de ejemplo simplificado.

También he intentado implementar IEquatable, ==,! = Y GetHashCode. Mismos resultados

Answer 1

Los resultados que se ven provenir de una design compromise, tuplas son ahora compartido entre F # y C#. El punto principal es que todas las Tuplas están de hecho implementadas como tipos de referencia, eso no fue tan obvio.

La decisión de si Tuples debería hacer verificaciones de igualdad profundas o superficiales se movió a dos interfaces: IStructuralComparable, IStructuralEquatable. Tenga en cuenta que esos 2 ahora también están implementados por la clase Array.

Answer 2

Para Tipo de referencia: == realiza una comparación de identidad, es decir, solo devolverá verdadero si ambas referencias apuntan al mismo objeto. Aunque se espera que el método Equals() realice una comparación de valores, es decir, devolverá verdadero si las referencias apuntan a objetos que son equivalentes.

Para los tipos de referencia, donde == tiene NO sido sobrecargado, se compara si dos referencias se refieren al mismo objeto

Answer 3

Por defecto, el operador == pruebas de referencia por la igualdad, por lo Sí el resultado que están viendo se espera.

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

En C#, hay dos tipos diferentes de la igualdad: la igualdad de referencia (también conocido como identidad) y la igualdad de valor. La igualdad de valor es generalmente el significado entendido de igualdad de : significa que dos objetos contienen los mismos valores . Por ejemplo, dos enteros con el valor de 2 tienen el valor igualdad. La igualdad de referencia significa que no hay dos objetos para comparar.

Answer 4

Por defecto, == (en una clase) significa igualdad de referencia; es decir, son la misma instancia; lo que object.ReferenceEquals(x,y) devolvería.

Puede proporcionar la suya == /!= Operadores para obtener el comportamiento esperado - y cuando se reemplaza Equals es importante para anular GetHashCode también (de lo contrario se rompe uso como clave - 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(); 
}