Qual è la differenza tra IEquatable e semplicemente ignorando Object.Equals ()?

Voglio che la mia Foodclasse sia in grado di testare ogni volta che è uguale a un'altra istanza di Food. Lo userò successivamente contro un elenco e voglio usare il suo List.Contains()metodo. Devo implementare IEquatable<Food>o semplicemente sostituire Object.Equals()? Da MSDN:

Questo metodo determina l'uguaglianza utilizzando il comparatore di uguaglianza predefinito, come definito dall'implementazione dell'oggetto del metodo IEquatable.Equals per T (il tipo di valori nell'elenco).

Quindi la mia prossima domanda è: quali funzioni / classi del framework .NET fanno uso Object.Equals()? Dovrei usarlo in primo luogo?

Il motivo principale è la prestazione. Quando i generici sono stati introdotti in .NET 2.0 sono stati in grado di aggiungere un po 'di lezioni di pulito, come List<T>, Dictionary<K,V>, HashSet<T>, ecc Queste strutture fanno pesante uso di GetHashCodee Equals. Ma per i tipi di valore questo ha richiesto il pugilato. IEquatable<T>consente a una struttura di implementare un Equalsmetodo fortemente tipizzato , quindi non è necessario il pugilato. Prestazioni quindi molto migliori quando si utilizzano tipi di valore con raccolte generiche.

I tipi di riferimento non ne beneficiano molto, ma l' IEquatable<T>implementazione ti consente di evitare un cast dal System.Objectquale può fare la differenza se viene chiamato frequentemente.

Come notato sul blog di Jared Parson, tuttavia, è ancora necessario implementare le sostituzioni di oggetti.

Secondo il MSDN :

Se si implementa IEquatable<T>, è necessario sostituire anche le implementazioni della classe base Object.Equals(Object)e in GetHashCode modo che il loro comportamento sia coerente con quello del IEquatable<T>.Equals metodo. Se esegui l'override Object.Equals(Object), l'implementazione override viene anche chiamata nelle chiamate al Equals(System.Object, System.Object)metodo statico sulla tua classe. Ciò garantisce che tutte le invocazioni del Equalsmetodo restituiscano risultati coerenti.

Quindi sembra che non ci sia una reale differenza funzionale tra i due, tranne che uno dei due potrebbe essere chiamato a seconda di come viene utilizzata la classe. Dal punto di vista delle prestazioni, è meglio utilizzare la versione generica perché non vi è alcuna penalità di boxe / unboxing ad essa associata.

Dal punto di vista logico, è anche meglio implementare l'interfaccia. Sostituire l'oggetto in realtà non dice a nessuno che la tua classe è effettivamente equabile. L'override può essere semplicemente una classe do nothing o un'implementazione superficiale. Usando l'interfaccia dice esplicitamente: "Ehi, questa cosa è valida per il controllo dell'uguaglianza!" È solo un design migliore.

Estendere ciò che Josh ha detto con un esempio pratico. +1 a Josh - Stavo per scrivere lo stesso nella mia risposta.

public abstract class EntityBase : IEquatable<EntityBase>
{
    public EntityBase() { }

    #region IEquatable<EntityBase> Members

    public bool Equals(EntityBase other)
    {
        //Generic implementation of equality using reflection on derived class instance.
        return true;
    }

    public override bool Equals(object obj)
    {
        return this.Equals(obj as EntityBase);
    }

    #endregion
}

public class Author : EntityBase
{
    public Author() { }
}

public class Book : EntityBase
{
    public Book() { }
}

In questo modo, ho un metodo Equals () riutilizzabile pronto all'uso per tutte le mie classi derivate.

Se chiamiamo object.Equals , impone costosi inscatolamento su tipi di valore. Ciò è indesiderabile in scenari sensibili alle prestazioni. La soluzione è quella di utilizzare IEquatable<T>.

public interface IEquatable<T>
{
  bool Equals (T other);
}

L'idea alla base IEquatable<T>è che dà lo stesso risultato diobject.Equals ma più rapidamente. Il vincolo where T : IEquatable<T>deve essere utilizzato con tipi generici come di seguito.

public class Test<T> where T : IEquatable<T>
{
  public bool IsEqual (T a, T b)
  {
    return a.Equals (b); // No boxing with generic T
  }
}

altrimenti, si lega a slower object.Equals().