Wyrażenia lambda i delegaty do porównywania

1. Wprowadzenie

Wyobraź sobie, że masz listę studentów i musisz ich posortować raz po wieku, potem po nazwisku, potem po średniej ocenie, ale tylko tych, którzy zdali wszystkie egzaminy. Jeśli dla każdego takiego "jednorazowego" porównania będziesz pisać całą nową klasę implementującą IComparer<T>, twój projekt szybko zamieni się w śmietnik małych klas-komparatorów. To niewygodne: kod robi się ociężały i nieczytelny.

W takich sytuacjach C# daje nam bardziej eleganckie rozwiązanie: możliwość przekazania logiki porównania bezpośrednio do metody Sort bez tworzenia osobnej klasy.

Do tego potrzebujemy delegatów i ich kompaktowych braci – wyrażeń lambda.

Delegaty – nasi elastyczni pomocnicy

Zanim przejdziemy do lambd, ogarnijmy, czym jest delegat. Prosto mówiąc, delegat to typ, który jest referencją do metody. Brzmi trochę metafizycznie, nie? Pomyśl o tym tak:

Wyobraź sobie, że masz listę rzeczy do zrobienia, a niektóre z tych rzeczy to "instrukcje" albo "przepisy". Delegat to taka specjalna zmienna, która może przechowywać referencję do takiego "przepisu" (metody). A potem, kiedy trzeba wykonać to zadanie, po prostu odwołujesz się do zmiennej-delegata i ona "wywołuje" tę metodę, do której się odnosi.

W C# delegaty są używane do tworzenia callbacków (wywołania metody później, zwykle jako reakcja na zdarzenie), obsługi zdarzeń (reagowania na akcje, np. kliknięcie przycisku) i oczywiście do przekazywania metod jako argumentów do innych metod (żeby metoda mogła wywołać inną metodę), co właśnie teraz nam się przyda do sortowania.

Metoda List<T>.Sort() ma kilka przeciążeń (wersji), a jedno z nich przyjmuje specjalnego delegata o nazwie Comparison<T>.

2. Delegat Comparison<T>

Czym jest Comparison<T>?

Comparison<T> to wbudowany w .NET delegat, który został specjalnie stworzony do porównywania dwóch obiektów tego samego typu T. Jego "przepis" wygląda tak: przyjmuje dwa obiekty typu T (nazwijmy je x i y) i zwraca liczbę całkowitą (int):

• Liczba ujemna (np. -1), jeśli x jest "mniejszy" od y.
• Zero (0), jeśli x jest "równy" y.
• Liczba dodatnia (np. 1), jeśli x jest "większy" od y.

Dokładnie według tych zasad działają też IComparable.CompareTo i IComparer.Compare. Czyli logika ta sama, tylko teraz możemy ją przekazać jako "zmienną-metodę", a nie osobną klasę.

Zobaczmy na przykładzie. Wróćmy do naszych studentów. Załóżmy, że mamy klasę Student:

public class Student
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
    public double AverageGrade { get; set; }

    public Student(string firstName, string lastName, int age, double averageGrade)
    {
        FirstName = firstName;
        LastName = lastName;
        Age = age;
        AverageGrade = averageGrade;
    }

    public void PrintInfo()
    {
        Console.WriteLine($"Student: {FirstName} {LastName}, Wiek: {Age}, Ocena: {AverageGrade:F2}");
    }
}

Teraz, żeby posortować listę studentów po wieku używając delegata, możemy napisać osobną statyczną metodę, która pasuje do sygnatury Comparison<Student>:

public class Program
{
    // Metoda, która pasuje do sygnatury delegata Comparison<Student>
    // Będzie porównywać dwóch studentów po ich wieku
    public static int CompareStudentsByAge(Student student1, Student student2)
    {
        // Używamy wbudowanej metody CompareTo dla liczb,
        // która zwraca -1, 0 lub 1 w zależności od porównania.
        return student1.Age.CompareTo(student2.Age);
    }

    public static void Main(string[] args)
    {
        List<Student> students = new List<Student>
        {
            new Student("Ivan", "Petrov", 20, 4.5),
            new Student("Maria", "Sidorova", 22, 4.8),
            new Student("Aleksey", "Ivanov", 19, 3.9),
            new Student("Elena", "Kozlova", 20, 4.2) // Dwóch studentów w tym samym wieku
        };

        Console.WriteLine("--- Lista studentów przed sortowaniem ---");        
        foreach (var s in students)
            s.PrintInfo();

        Console.WriteLine("--- Sortujemy studentów po wieku (używając delegata) ---");
        students.Sort(CompareStudentsByAge); //przekazujemy metodę CompareStudentsByAge jako parametr

        foreach (var s in students)
            s.PrintInfo();
    }
}

Rozkładamy kod na czynniki pierwsze:

1. Stworzyliśmy statyczną metodę CompareStudentsByAge, która przyjmuje dwóch studentów i zwraca int, zgodnie z kontraktem Comparison<Student>.
2. W Main stworzyliśmy listę studentów.
3. Kiedy wywołujemy students.Sort(CompareStudentsByAge);, nie wywołujemy od razu metody CompareStudentsByAge()! Po prostu przekazujemy referencję do tej metody. List<T>.Sort() potem sam wywoła naszą metodę CompareStudentsByAge tyle razy, ile będzie trzeba do sortowania, przekazując jej różne pary studentów. To trochę jakbyś dawał komuś adres dostawy, a nie od razu wysyłał tam całą ciężarówkę.

To podejście jest dużo wygodniejsze niż tworzenie osobnej klasy-komparatora dla każdego drobnego sortowania. Ale można pójść jeszcze dalej!

3. Poznaj Wyrażenia Lambda

Nawet konieczność pisania osobnej metody, jak CompareStudentsByAge, może wydawać się zbędna, jeśli logika porównania jest prosta i potrzebna tylko raz czy dwa. Do takich sytuacji w C# wprowadzono wyrażenia lambda (lambda expressions).

Czym jest wyrażenie lambda? To w zasadzie anonimowa metoda albo, jak lubię żartować, "bezdomna metoda". To sposób na napisanie krótkiego kawałka kodu (metody) dokładnie tam, gdzie jest potrzebny, bez deklarowania go osobno. To jak szybkie napisanie instrukcji na karteczce i przyklejenie jej do zadania, zamiast pisać cały podręcznik.

Główny operator wyrażenia lambda to => (czytamy jako "strzałka" albo "przechodzi w"). Oddziela parametry wejściowe od ciała metody.

Podstawowa składnia wyrażenia lambda

Załóżmy, że masz delegata (referencję do metody) i przekazujesz go do funkcji Sort():

public static int CompareStudentsByAge(Student student1, Student student2)
{
   return student1.Age.CompareTo(student2.Age);
}

students.Sort(CompareStudentsByAge); //przekazujemy metodę CompareStudentsByAge jako parametr

Można to zapisać krócej:

//przekazujemy metodę anonimową jako parametr
students.Sort( (Student student1, Student student2) => student1.Age.CompareTo(student2.Age) );

Tutaj zamiast nazwy metody podstawiamy jej dwie najważniejsze rzeczy:

• parametry: (Student student1, Student student2)
• zawartość metody: student1.Age.CompareTo(student2.Age)

Taki kompaktowy zapis metody to właśnie wyrażenie lambda: (parametry) => wyrażenie

Jak to działa

Kompilator C#, gdy napotka w kodzie wyrażenie lambda, wygeneruje na jego podstawie prawdziwą metodę.

Załóżmy, że masz taki kod:

students.Sort( (s1, s2) => s2.AverageGrade.CompareTo(s1.AverageGrade) );

Efekt kompilacji będzie mniej więcej taki:

public static int CompareStudents_Lambda123(Student s1, Student s2)
{
   return s2.AverageGrade.CompareTo(s1.AverageGrade);
}

students.Sort( CompareStudents_Lambda123 );

4. Przykład sortowania i wyrażenia lambda

Przepiszmy nasz przykład ze studentami, używając wyrażenia lambda:

public class Program
{
    public static void Main(string[] args)
    {
        List<Student> students = new List<Student>
        {
            new Student("Ivan", "Petrov", 20, 4.5),
            new Student("Maria", "Sidorova", 22, 4.8),
            new Student("Aleksey", "Ivanov", 19, 3.9),
            new Student("Elena", "Kozlova", 20, 4.2)
        };

        Console.WriteLine("--- Lista studentów przed sortowaniem ---");        
        foreach (var s in students)
            s.PrintInfo();

        // Teraz logika porównania jest napisana tu, "na miejscu"
        Console.WriteLine("--- Sortujemy studentów po wieku (używając wyrażenia lambda) ---");
        students.Sort((student1, student2) => student1.Age.CompareTo(student2.Age));

        foreach (var s in students)
            s.PrintInfo();

        // Żeby posortować malejąco, po prostu mnożymy wynik przez -1
        Console.WriteLine("\n--- Sortujemy studentów po średniej ocenie (malejąco) ---");
        // s2.CompareTo(s1) zamiast s1.CompareTo(s2)
        students.Sort((s1, s2) => s2.AverageGrade.CompareTo(s1.AverageGrade));

        foreach (var s in students)
            s.PrintInfo();
    }
}

Co tu się wydarzyło?

1. students.Sort((student1, student2) => student1.Age.CompareTo(student2.Age));
   • student1 i student2 – to parametry, które Sort będzie przekazywać naszej anonimowej metodzie (podobnie jak x i y w Comparison<T>).
   • => – to operator lambda.
   • student1.Age.CompareTo(student2.Age) – to ciało wyrażenia lambda. W tym przypadku to tylko jedno wyrażenie, którego wynik jest zwracany.
2. Żeby posortować po średniej ocenie malejąco, po prostu zamieniliśmy miejscami s1 i s2 w CompareTo. To klasyczny trik na odwrócenie kolejności sortowania.

Dlaczego to wygodne?

• Kompaktowość: Nie trzeba tworzyć osobnych metod czy klas dla każdej drobnej logiki porównania.
• Czytelność: Logika porównania jest tuż obok wywołania Sort(), co poprawia zrozumienie kodu, zwłaszcza w prostych przypadkach.
• Elastyczność: Możesz łatwo zmieniać warunki sortowania "w locie".

5. Delegaty i Lambdy – idealny duet

Możesz się zastanawiać: czy wyrażenie lambda to to samo co delegat, czy coś innego?

Tak naprawdę wyrażenie lambda to po prostu cukier składniowy (syntax sugar) do tworzenia instancji delegata lub drzewa wyrażeń (Expression Tree, o tym później). Kiedy kompilator widzi wyrażenie lambda, sam, "pod maską", zamienia je na instancję odpowiedniego delegata. W naszym przypadku, ponieważ List<T>.Sort() oczekuje delegata Comparison<T>, kompilator wie, że (student1, student2) => student1.Age.CompareTo(student2.Age) trzeba zamienić właśnie na Comparison<Student>.

Dzięki temu wyrażenia lambda pozwalają pisać bardzo zwięzły kod, a delegaty to te "kontenery", które ten kod przenoszą i pozwalają go wykonać. Działają razem, ramię w ramię!

Kiedy czego używać?

• IComparable<T>: Używaj, gdy twój typ ma naturalny, oczywisty sposób sortowania. Na przykład, jeśli sortujesz produkty i główny sposób sortowania to po ich numerze katalogowym. Ten interfejs określa domyślną kolejność.
• IComparer<T>: Używaj, gdy potrzebujesz wielokrotnej, wielorazowej logiki porównania, ale nie chcesz "zaśmiecać" głównej klasy albo masz kilka różnych sposobów sortowania. Na przykład jeden IComparer do sortowania produktów po cenie, inny po nazwie i używasz ich w różnych częściach programu.
• Delegaty (Comparison<T>) i Wyrażenia lambda: Idealne do jednorazowych, ad-hoc sortowań, gdy logika porównania jest prosta i nie wymaga osobnej klasy do wielokrotnego użycia. To najczęstszy i najczystszy sposób dla większości zadań sortowania w C#. To też świetny sposób na przekazywanie logiki do innych metod, np. do metod filtrowania (Find, FindAll) czy wyszukiwania (FindIndex), które omawialiśmy wcześniej.

someList.Sort()

someList.Sort(new MyComparer())

someList.Sort((x, y) => x.Prop.CompareTo(y.Prop))

6. Praktyczne zastosowanie i spojrzenie w przyszłość

Wyrażenia lambda to nie tylko "cukier składniowy" do sortowania. To potężne narzędzie, które jest wszędzie w nowoczesnym kodzie C#. Będziesz je widzieć bardzo często:

• W LINQ (Language Integrated Query): To chyba najczęstsze zastosowanie wyrażeń lambda. LINQ pozwala pisać zapytania podobne do SQL do kolekcji, a lambdy służą do określania warunków filtrowania, sortowania, projekcji danych. Wkrótce będziemy się uczyć LINQ i zobaczysz, jak lambdy czynią go mega potężnym i wygodnym.
• W obsłudze zdarzeń: Lambdy pozwalają zwięźle opisać, co ma się stać przy jakimś zdarzeniu (np. kliknięciu przycisku w interfejsie użytkownika).
• W programowaniu asynchronicznym: Do określania zadań, które mają być wykonywane równolegle.
• W różnych API .NET: Wiele metod w standardowej bibliotece .NET przyjmuje delegaty (a więc i wyrażenia lambda) jako parametry, żeby dodać elastyczną logikę.

Tak więc, ogarniając wyrażenia lambda, nie tylko poprawisz swoje umiejętności sortowania, ale zrobisz ogromny krok do zrozumienia nowoczesnego kodu C# i bibliotek. To skill, który będzie doceniony na każdej rozmowie i przyda się w każdym projekcie!

7. Typowe błędy i niuanse

Kiedy pracujesz z delegatami i wyrażeniami lambda do porównywania, jest kilka rzeczy, na które warto uważać:

Zły wynik porównania: Pamiętaj, że CompareTo albo twoja logika porównania powinna zwracać liczbę ujemną, zero lub dodatnią. Jeśli przypadkiem zwrócisz coś innego, sortowanie może działać źle albo nawet rzucić błędem. Najczęstszy błąd – początkujący zwracają true albo false zamiast int. Metoda Sort oczekuje właśnie liczby, bo potrzebuje wiedzieć nie tylko, czy elementy są równe, ale też który jest "większy".

Obsługa null: Jeśli elementy w twojej kolekcji mogą być null, próba wywołania metody na null (np. student1.Age.CompareTo(...), jeśli student1 to null) skończy się NullReferenceException. W takich przypadkach twoja logika porównania powinna jawnie obsługiwać null. Ogólna zasada: null jest "mniejsze" od każdego nie-null. Jeśli oba są null, są równe. Jeśli jeden null, a drugi nie, null jest "mniejsze".

// Przykład obsługi null w wyrażeniu lambda do porównania
students.Sort((s1, s2) => {
    if (s1 == null && s2 == null) return 0;
    if (s1 == null) return -1; // null mniejsze od wszystkiego
    if (s2 == null) return 1;  // nie-null większe od null
    return s1.Age.CompareTo(s2.Age); // Porównujemy, jeśli oba nie są null
});

Na szczęście w prawdziwych projektach bardzo często kolekcje nie zawierają null, ale warto o tym pamiętać!

Wydajność: Chociaż wyrażenia lambda są mega wygodne, czasem ich nadmierne używanie w bardzo "gorących" pętlach albo dla bardzo dużych kolekcji może minimalnie wpłynąć na wydajność w porównaniu do wysoko zoptymalizowanych klas IComparer, które być może były dokładnie testowane i profilowane. Jednak w większości codziennych zadań różnica będzie nieistotna, a zysk w czytelności i prostocie kodu zdecydowanie przeważa.

Złożone łańcuchy porównań: Jak widzieliśmy w przykładzie z sortowaniem po nazwisku, potem po imieniu, wyrażenia lambda pozwalają zagnieżdżać kilka warunków. To dużo wygodniejsze niż pisanie dziesięciu if w jednej linii! Najważniejsze — zawsze najpierw sprawdź wynik pierwszego porównania (lastNameComparison != 0) i dopiero potem przechodź do kolejnego poziomu zagnieżdżenia.

Wyrażenia lambda i delegaty to fundamentalne koncepcje w C#, które otwierają drzwi do bardziej elastycznego i funkcyjnego stylu programowania. Ich zrozumienie i umiejętność stosowania sprawią, że twój kod będzie dużo czystszy, efektywniejszy i nowocześniejszy. Eksperymentuj dalej, a wkrótce będziesz ich używać automatycznie!