IComparable - jak porównuje się obiekty w C#
Trzy różne pytania o "porównywanie" obiektów
Zanim przejdziemy do IComparable, warto rozdzielić trzy różne pytania, które łatwo się myli, bo wszystkie nazywamy "porównywaniem":
- "Czy te dwa obiekty są takie same?" - to jest
Equals()/GetHashCode(), o czym mówiliśmy przyrecordvsclass - "Który obiekt jest mniejszy/większy?" - to jest
IComparable<T>/CompareTo()- temat tej strony - "Czy ten obiekt jest identyczny w pamięci?" - to jest
ReferenceEquals()
IComparable odpowiada tylko na drugie pytanie - definiuje naturalną kolejność sortowania dla typu.
Interfejs IComparable<T> - definicja
public interface IComparable<T>
{
int CompareTo(T other);
}
Kontrakt zwracanej wartości - to jest najważniejsza rzecz do zapamiętania:
Wynik CompareTo() |
Znaczenie |
|---|---|
| Wartość ujemna (np. -1) | Obiekt bieżący jest "mniejszy" niż other |
| Zero | Obiekty są "równe" pod względem kolejności sortowania |
| Wartość dodatnia (np. 1) | Obiekt bieżący jest "większy" niż other |
Ważna pułapka pojęciowa: CompareTo() == 0 nie musi oznaczać, że obiekty są "równe" w sensie Equals() - to są dwa niezależne kontrakty. Może się zdarzyć, że sortujesz zamówienia po dacie, i dwa różne zamówienia mają identyczną datę (CompareTo() == 0), ale to zupełnie różne obiekty (Equals() zwróci false).
Implementacja - konkretny przykład
public class Order : IComparable<Order>
{
public int Id { get; set; }
public decimal TotalAmount { get; set; }
public int CompareTo(Order other)
{
if (other == null) return 1; // każdy obiekt jest "większy" niż null
return TotalAmount.CompareTo(other.TotalAmount); // deleguj do CompareTo typu decimal
}
}
var order1 = new Order { Id = 1, TotalAmount = 100 };
var order2 = new Order { Id = 2, TotalAmount = 250 };
int result = order1.CompareTo(order2); // -1 (albo inna wartość ujemna) - order1 jest "mniejszy"
Zauważ, że implementacja deleguje porównanie do TotalAmount.CompareTo(other.TotalAmount) - decimal (podobnie jak int, string, DateTime) już implementuje IComparable<T> wewnętrznie, więc nie musisz pisać logiki porównania "ręcznie" (sprawdzać <, > osobno).
Dlaczego to jest przydatne - Array.Sort() / List<T>.Sort()
var orders = new List<Order>
{
new Order { Id = 1, TotalAmount = 300 },
new Order { Id = 2, TotalAmount = 100 },
new Order { Id = 3, TotalAmount = 200 }
};
orders.Sort(); // działa TYLKO dlatego, że Order implementuje IComparable<Order>!
// wynik: [100, 200, 300] - sortowanie po TotalAmount, bo tak zdefiniowaliśmy CompareTo
Bez implementacji IComparable<Order>, wywołanie orders.Sort() nie skompilowałoby się (albo, dla starszego niegenerycznego IComparable, rzuciłoby wyjątek w runtime) - List<T>.Sort() bezparametrowe wymaga, żeby typ elementów sam wiedział, jak się porównywać.
SortedSet<Order> sortedOrders = new(); // TEŻ wymaga IComparable<Order> (albo IComparer<Order>)
sortedOrders.Add(order1);
sortedOrders.Add(order2); // automatycznie wstawiony we WŁAŚCIWYM miejscu, zgodnie z CompareTo
IComparer<T> - gdy potrzebujesz WIELU różnych sposobów porównywania
IComparable<T> daje tylko jedną, "naturalną" kolejność (tu: po TotalAmount). Co, jeśli czasem chcesz sortować po nazwie klienta, a czasem po dacie? Do tego służy osobny interfejs IComparer<T> - zewnętrzny komparator, niezależny od samej klasy:
public class OrderByCustomerNameComparer : IComparer<Order>
{
public int Compare(Order x, Order y) => string.Compare(x.CustomerName, y.CustomerName);
}
public class OrderByDateComparer : IComparer<Order>
{
public int Compare(Order x, Order y) => x.CreatedDate.CompareTo(y.CreatedDate);
}
orders.Sort(new OrderByCustomerNameComparer()); // sortowanie po IMIENIU klienta
orders.Sort(new OrderByDateComparer()); // sortowanie po DACIE
orders.Sort(); // domyślne CompareTo - po TotalAmount
Różnica w skrócie: IComparable<T> implementujesz na samej klasie (jedna, "naturalna" kolejność), IComparer<T> piszesz jako osobną klasę, kiedy potrzebujesz wielu, alternatywnych sposobów sortowania tego samego typu.
LINQ OrderBy - NIE wymaga IComparable na Twojej klasie
To jest częsta pułapka pojęciowa, warto rozróżnić:
// OrderBy w LINQ - działa BEZ implementowania IComparable na Order!
var sorted = orders.OrderBy(o => o.TotalAmount); // wymaga IComparable TYLKO na TYPIE KLUCZA (decimal), nie na Order
var sortedByName = orders.OrderBy(o => o.CustomerName); // string też ma wbudowany IComparable
OrderBy(keySelector) wymaga, żeby typ zwracany przez lambdę (tu: decimal, string) implementował IComparable - nie wymaga tego od całej klasy Order. Dlatego OrderBy działa na dowolnej klasie, nawet bez żadnej implementacji IComparable, o ile wybierasz klucz sortowania, który sam jest porównywalny (co dotyczy praktycznie wszystkich wbudowanych typów: int, string, DateTime, decimal).
orders.Sort(); // ❌ Błąd kompilacji, jeśli Order NIE implementuje IComparable<Order>
orders.OrderBy(o => o.TotalAmount); // ✅ Działa ZAWSZE, niezależnie od tego, czy Order implementuje IComparable
IComparable a operatory <, >, <=, >=
Implementacja IComparable<T> nie daje Ci automatycznie możliwości pisania order1 < order2 - żeby to uzyskać, musisz osobno przeciążyć operatory:
public class Order : IComparable<Order>
{
public decimal TotalAmount { get; set; }
public int CompareTo(Order other) => TotalAmount.CompareTo(other?.TotalAmount ?? 0);
// Operatory to ODDZIELNA deklaracja - IComparable ich NIE daje "za darmo"
public static bool operator <(Order left, Order right) => left.CompareTo(right) < 0;
public static bool operator >(Order left, Order right) => left.CompareTo(right) > 0;
public static bool operator <=(Order left, Order right) => left.CompareTo(right) <= 0;
public static bool operator >=(Order left, Order right) => left.CompareTo(right) >= 0;
}
if (order1 < order2) { /* ... */ } // TERAZ działa, bo jawnie przeciążyliśmy operator
Niegeneryczny IComparable (bez <T>) - historyczna wersja
Warto wiedzieć, że istnieje też starsza, niegeneryczna wersja z czasów przed generykami w .NET (C# 1.0):
public interface IComparable
{
int CompareTo(object obj); // przyjmuje "object", wymaga rzutowania w środku
}
public class Order : IComparable
{
public int CompareTo(object obj)
{
if (obj is not Order other) throw new ArgumentException("Obiekt musi być typu Order");
return TotalAmount.CompareTo(other.TotalAmount);
}
}
Dlaczego generyczny IComparable<T> jest lepszy: unika boxing (dla structów - wracając do rozmowy o struct) i rzutowania w runtime - CompareTo(Order other) jest sprawdzane przez kompilator w compile-time, CompareTo(object obj) rzuca wyjątek w runtime, jeśli ktoś przekaże złudny typ. W nowoczesnym kodzie zawsze implementuj generyczną wersję (IComparable<T>), niegeneryczna jest zachowana głównie dla kompatybilności ze starszym kodem.
Podsumowanie - zwięzła odpowiedź na rozmowę
IComparable<T>definiuje naturalną kolejność sortowania obiektu przez metodęCompareTo(), zwracającą wartość ujemną/zero/dodatnią w zależności od tego, czy obiekt jest mniejszy, równy (pod względem porządku, nie tożsamości!) czy większy od porównywanego. Implementacja tego interfejsu jest wymagana, żeby bezparametroweList<T>.Sort()czySortedSet<T>w ogóle działały. Gdy potrzebujesz wielu różnych sposobów sortowania tego samego typu, używasz zamiast tego (albo dodatkowo) osobnych klas implementującychIComparer<T>. LINQOrderBy(keySelector)nie wymagaIComparablena całej klasie - tylko na typie klucza wybranego w lambdzie, co jest częstym źródłem nieporozumień przy porównywaniu tych dwóch mechanizmów sortowania.