C# / .NET Kompendium PLEN
.NET / C# / Algorytmy, struktury danych

IEquatable<T>

Co to jest

IEquatable<T> to generyczny interfejs z System, który definiuje jedną metodę:

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

Implementując go, mówimy: "mój typ umie porównać się z konkretnym, znanym typem T — bez castowania i bez boxingu".

Dlaczego samo Equals(object) nie wystarcza

Każdy typ w .NET dziedziczy Equals(object obj) po System.Object. Problem w tym, że:

  • parametr jest typu object, więc trzeba go zrzutować ((Order)obj) i sprawdzić is/as — dodatkowy narzut,
  • dla struktur (struct) wywołanie Equals(object) wymaga boxingu wartości (bo object to referencja), co jest kosztowne i generuje śmieci na GC,
  • domyślna implementacja ValueType.Equals dla structów korzysta z refleksji, co jest wolne.

IEquatable<T> rozwiązuje to, dając silnie typowaną, bezpośrednią metodę porównania — bez castowania, bez boxingu, bez refleksji.

Pełny przykład

public class Order : IEquatable<Order>
{
    public Guid Id { get; }
    public decimal Amount { get; }

    public Order(Guid id, decimal amount)
    {
        Id = id;
        Amount = amount;
    }

    // Silnie typowane porównanie - to jest serce IEquatable<T>
    public bool Equals(Order? other)
    {
        if (other is null) return false;
        if (ReferenceEquals(this, other)) return true;

        return Id == other.Id && Amount == other.Amount;
    }

    // Equals(object) delegujemy do Equals(Order)
    public override bool Equals(object? obj) => Equals(obj as Order);

    public override int GetHashCode() => HashCode.Combine(Id, Amount);

    public static bool operator ==(Order? left, Order? right)
    {
        if (left is null) return right is null;
        return left.Equals(right);
    }

    public static bool operator !=(Order? left, Order? right) => !(left == right);
}

Reguła, której trzeba się trzymać: jeśli przeciążasz Equals, musisz też przeciążyć GetHashCode() — dwa obiekty "równe" muszą mieć ten samy hash code, inaczej Dictionary/HashSet się rozsypie.

Gdzie to ma znaczenie w praktyce

  • List<T>.Contains, IndexOf, Remove — jeśli T implementuje IEquatable<T>, kolekcja użyje go bezpośrednio. Jeśli nie — spada na Equals(object) (wolniej, z castowaniem).
  • Dictionary<TKey, TValue> i HashSet<T> — domyślny EqualityComparer<T>.Default sprawdza w runtime, czy T implementuje IEquatable<T>, i jeśli tak, używa go. Dla structów to jest ogromna różnica wydajnościowa (brak boxingu przy każdym sprawdzeniu).
  • Struktury (struct) — tutaj zysk jest największy. Struct bez IEquatable<T> boksuje się przy każdym porównaniu w kolekcji. Z IEquatable<T> — zero alokacji.
public readonly struct Point : IEquatable<Point>
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y) { X = x; Y = y; }

    public bool Equals(Point other) => X == other.X && Y == other.Y;
    public override bool Equals(object? obj) => obj is Point p && Equals(p);
    public override int GetHashCode() => HashCode.Combine(X, Y);
}

Bez IEquatable<Point>, każde list.Contains(point) boksowałoby Point do object pod maską — z interfejsem tego unikamy całkowicie.

A co z record?

Typy record automatycznie generują implementację porównania wartościowego (member-wise), łącznie z Equals(T), Equals(object), GetHashCode() i operatorami ==/!= — czyli dokładnie to, co napisaliśmy ręcznie wyżej. To jeden z głównych powodów, dla których record jest wygodny dla DTO/value objects — nie trzeba pisać tego boilerplate'u samemu.

public record OrderDto(Guid Id, decimal Amount);
// IEquatable<OrderDto> + Equals + GetHashCode + == + != - wszystko za darmo

Podsumowanie

Aspekt Equals(object) IEquatable<T>.Equals(T)
Typowanie słabe (object) silne (T)
Boxing dla struct tak nie
Wydajność w kolekcjach wolniej (cast + ew. boxing) szybciej (bezpośrednie wywołanie)
Wymagany też GetHashCode tak tak
Generowany automatycznie przez record tak tak
Postaw mi kawę