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łanieEquals(object)wymaga boxingu wartości (boobjectto referencja), co jest kosztowne i generuje śmieci na GC, - domyślna implementacja
ValueType.Equalsdla 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śliTimplementujeIEquatable<T>, kolekcja użyje go bezpośrednio. Jeśli nie — spada naEquals(object)(wolniej, z castowaniem).Dictionary<TKey, TValue>iHashSet<T>— domyślnyEqualityComparer<T>.Defaultsprawdza w runtime, czyTimplementujeIEquatable<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 bezIEquatable<T>boksuje się przy każdym porównaniu w kolekcji. ZIEquatable<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 |