Qual è la differenza tra IEqualityComparer <T> e IEquatable <T>?

Voglio capire gli scenari dove IEqualityComparer<T>e IEquatable<T>dovrebbero essere usati. La documentazione MSDN per entrambi sembra molto simile.

IEqualityComparer<T>è un'interfaccia per un oggetto che esegue il confronto su due oggetti del tipo T.

IEquatable<T>è per un oggetto di tipo in Tmodo che possa confrontarsi con un altro dello stesso tipo.

Quando si decide se utilizzare IEquatable<T>o IEqualityComparer<T>, si potrebbe chiedere:

Esiste un modo preferito di testare due casi di Tuguaglianza o ci sono molti modi ugualmente validi?

• Se esiste un solo modo per testare due istanze di Tper l'uguaglianza, o se si preferisce uno dei diversi metodi, allora IEquatable<T>sarebbe la scelta giusta: questa interfaccia dovrebbe essere implementata solo da Tsola, in modo che un'istanza Tabbia una conoscenza interna di come confrontarsi con un'altra istanza di T.

• D'altra parte, se esistono diversi metodi ugualmente ragionevoli per confrontare due Ts per l'uguaglianza, IEqualityComparer<T>sembrerebbe più appropriato: questa interfaccia non è pensata per essere implementata da Tsola, ma da altre classi "esterne". Pertanto, quando si verificano due istanze Tper l'uguaglianza, poiché Tnon ha una comprensione interna dell'uguaglianza, sarà necessario fare una scelta esplicita di IEqualityComparer<T>un'istanza che esegue il test in base alle proprie esigenze specifiche.

Esempio:

Consideriamo questi due tipi (che dovrebbero avere una semantica di valore ):

interface IIntPoint : IEquatable<IIntPoint>
{
    int X { get; }
    int Y { get; }
}

interface IDoublePoint  // does not inherit IEquatable<IDoublePoint>; see below.
{
    double X { get; }
    double Y { get; }
}

Perché solo uno di questi tipi erediterebbe IEquatable<>, ma non l'altro?

In teoria, esiste un solo modo ragionevole per confrontare due istanze di entrambi i tipi: sono uguali se le proprietà Xe Yin entrambi i casi sono uguali. Secondo questo pensiero, entrambi i tipi dovrebbero implementarsi IEquatable<>, perché non sembra probabile che ci siano altri modi significativi di fare un test di uguaglianza.

Il problema qui è che il confronto di numeri in virgola mobile per l'uguaglianza potrebbe non funzionare come previsto, a causa di errori di arrotondamento minuti . Esistono diversi metodi per confrontare i numeri in virgola mobile per la quasi-uguaglianza , ciascuno con vantaggi e compromessi specifici e potresti voler scegliere tu stesso quale metodo è appropriato.

sealed class DoublePointNearEqualityComparerByTolerance : IEqualityComparer<IDoublePoint>
{
    public DoublePointNearEqualityComparerByTolerance(double tolerance) { … }
    …
    public bool Equals(IDoublePoint a, IDoublePoint b)
    {
        return Math.Abs(a.X - b.X) <= tolerance  &&  Math.Abs(a.Y - b.Y) <= tolerance;
    }
    …
}

Si noti che la pagina a cui ho collegato (sopra) afferma esplicitamente che questo test per la quasi uguaglianza presenta alcuni punti deboli. Poiché questa è IEqualityComparer<T>un'implementazione, puoi semplicemente cambiarla se non è abbastanza buona per i tuoi scopi.

Hai già ottenuto la definizione di base di ciò che sono . In breve, se si implementa IEquatable<T>in classe T, il Equalsmetodo su un oggetto di tipo Tindica se l'oggetto stesso (quello che viene testato per l'uguaglianza) è uguale a un'altra istanza dello stesso tipo T. Considerando che, IEqualityComparer<T>è per testare l'uguaglianza di due casi qualsiasi T, in genere al di fuori dell'ambito dei casi di T.

Quanto a cosa servono possono essere fonte di confusione all'inizio. Dalla definizione dovrebbe essere chiaro che quindi IEquatable<T>(definito nella classe Tstessa) dovrebbe essere lo standard di fatto per rappresentare l'unicità dei suoi oggetti / istanze. HashSet<T>, Dictionary<T, U>(Considerando GetHashCodeviene sovrascritto pure), Containsil List<T>etc fanno uso di questo. L'implementazione IEqualityComparer<T>su Tnon aiuta i casi generali sopra menzionati. Successivamente, c'è poco valore per l'implementazione IEquatable<T>su qualsiasi altra classe diversa da T. Questo:

class MyClass : IEquatable<T>

raramente ha senso.

D'altro canto

class T : IEquatable<T>
{
    //override ==, !=, GetHashCode and non generic Equals as well

    public bool Equals(T other)
    {
        //....
    }
}

è come dovrebbe essere fatto.

IEqualityComparer<T>può essere utile quando si richiede una convalida personalizzata dell'uguaglianza, ma non come regola generale. Ad esempio, in una classe Personad un certo punto potrebbe essere necessario testare l'uguaglianza di due persone in base alla loro età. In tal caso puoi fare:

class Person
{
    public int Age;
}

class AgeEqualityTester : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        return x.Age == y.Age;
    }

    public int GetHashCode(Person obj)
    {
        return obj.Age.GetHashCode;
    }
}

Per provarli, prova

var people = new Person[] { new Person { age = 23 } };
Person p = new Person() { age = 23 };

print people.Contains(p); //false;
print people.Contains(p, new AgeEqualityTester()); //true

Allo stesso modo IEqualityComparer<T>il Tnon ha senso.

class Person : IEqualityComparer<Person>

È vero che funziona, ma non ha un bell'aspetto per gli occhi e sconfigge la logica.

Di solito quello che ti serve è IEquatable<T>. Inoltre, idealmente, puoi averne solo uno IEquatable<T>mentre IEqualityComparer<T>sono possibili multipli in base a criteri diversi.

I IEqualityComparer<T>e IEquatable<T>sono esattamente analoghi a Comparer<T>e IComparable<T>che sono usati a fini di confronto piuttosto che equivalenti; un buon thread qui dove ho scritto la stessa risposta :)

IEqualityComparer deve essere utilizzato quando l'uguaglianza di due oggetti viene implementata esternamente, ad esempio se si desidera definire un comparatore per due tipi per i quali non si ha la fonte o per i casi in cui l'uguaglianza tra due cose ha senso solo in un contesto limitato.

IEquatable è da implementare per l'oggetto stesso (quello che viene confrontato per l'uguaglianza).

Uno confronta due Ts. L'altro può confrontarsi con gli altri T. Di solito, dovrai usarne solo uno alla volta, non entrambi.