Лямбда-вирази та делегати для порівняння

1. Вступ

Уявімо, що у вас є список студентів, і потрібно відсортувати їх спочатку за віком, потім за прізвищем, далі за середнім балом, але лише для тих, хто склав усі іспити. Якщо для кожного такого «одноразового» порівняння писати щоразу новий клас, який реалізує IComparer<T>, то ваш проєкт швидко перетвориться на звалище маленьких класів‑порівнювачів. Це незручно: код стає громіздким і важкочитним.

Для таких ситуацій C# пропонує елегантніше рішення: можливість передати логіку порівняння прямо у метод Sort без створення окремого класу.

Для цього нам знадобляться делегати та їхні компактні «родичі» — лямбда-вирази.

Делегати — наші гнучкі помічники

Перш ніж перейти до лямбд, розберімося, що таке делегат. Простими словами, делегат — це тип, що є посиланням на метод. Звучить трохи абстрактно, чи не так? Думайте про це так:

Уявіть, що у вас є список справ, і деякі з них — це «інструкції» або «рецепти». Делегат — це як спеціальна змінна, яка може зберігати посилання на такий «рецепт» (метод). А потім, коли потрібно виконати цю справу, ви просто звертаєтеся до змінної‑делегата, і вона «викликає» той метод, на який посилається.

У C# делегати використовують для створення зворотних викликів (виклик методу пізніше, зазвичай як реакція на подію), обробки подій (реакції на дії, наприклад, натискання кнопки) і, звісно, для передавання методів як аргументів іншим методам — саме це нам і знадобиться для сортування.

Метод List<T>.Sort() має кілька перевантажень (варіантів), і одна з них приймає спеціальний делегат під назвою Comparison<T>.

2. Делегат Comparison<T>

Що таке Comparison<T>?

Comparison<T> — це вбудований у .NET делегат, спеціально створений для порівняння двох об’єктів одного типу T. Його «рецепт» виглядає так: він приймає на вхід два об’єкти типу T (назвімо їх x і y) і повертає ціле число (int):

• Від’ємне число (наприклад, -1), якщо x «менше» y.
• Нуль (0), якщо x «дорівнює» y.
• Додатне число (наприклад, 1), якщо x «більше» y.

Саме за цими правилами працюють і IComparable.CompareTo, і IComparer.Compare. Тобто логіка та сама, тільки тепер ми можемо передати її у вигляді «змінної‑методу», а не окремого класу.

Погляньмо на прикладі. Повернімося до наших студентів. Припустімо, у нас є клас 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($"Студент: {FirstName} {LastName}, Вік: {Age}, Середній бал: {AverageGrade:F2}");
    }
}

Тепер, щоб відсортувати список студентів за віком, використовуючи делегат, можемо написати окремий статичний метод, який відповідає сигнатурі Comparison<Student>:

public class Program
{
    // Метод, який відповідає сигнатурі делегата Comparison<Student>.
    // Він порівнюватиме двох студентів за їхнім віком.
    public static int CompareStudentsByAge(Student student1, Student student2)
    {
        // Використовуємо вбудований метод CompareTo для чисел,
        // який повертає -1, 0 або 1 залежно від порівняння.
        return student1.Age.CompareTo(student2.Age);
    }

    public static void Main(string[] args)
    {
        List<Student> students = new List<Student>
        {
            new Student("Іван", "Петренко", 20, 4.5),
            new Student("Марія", "Сидоренко", 22, 4.8),
            new Student("Олексій", "Іваненко", 19, 3.9),
            new Student("Олена", "Козловська", 20, 4.2) // Два студенти одного віку
        };

        Console.WriteLine("— Список студентів до сортування —");        
        foreach (var s in students)
            s.PrintInfo();

        Console.WriteLine("— Сортуємо студентів за віком (використовуючи делегат) —");
        students.Sort(CompareStudentsByAge); // Передаємо метод CompareStudentsByAge як параметр.

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

Розбираємо код:

1. Ми створили статичний метод CompareStudentsByAge, який приймає двох студентів і повертає int, дотримуючись контракту Comparison<Student>.
2. У Main ми створили список студентів.
3. Коли ми викликаємо students.Sort(CompareStudentsByAge);, ми не викликаємо метод CompareStudentsByAge() одразу! Ми лише передаємо посилання на цей метод. List<T>.Sort() потім сам викликатиме наш метод CompareStudentsByAge стільки разів, скільки потрібно для сортування, передаючи йому різні пари студентів. Це дуже схоже на те, як ви даєте кур’єру адресу доставки, а не одразу везете туди всю вантажівку.

Такий підхід набагато зручніший, ніж створювати окремий клас‑порівнювач для кожного дрібного сортування. Утім можна піти ще далі!

3. Знайомтеся з лямбда-виразами

Навіть потреба писати окремий метод, як‑от CompareStudentsByAge, може здаватися зайвою, якщо логіка порівняння проста і потрібна лише раз чи двічі. Для таких випадків у C# з’явилися лямбда-вирази (lambda expressions).

Що таке лямбда-вираз? Це, по суті, анонімний метод або, як я люблю жартувати, «безхатній метод». Це спосіб написати коротенький шматок коду (метод) прямо там, де він потрібен, не оголошуючи його окремо. Наче швидко накидати інструкцію на стікері й приліпити її прямо до задачі, а не писати цілий мануал.

Основний оператор лямбда-виразу — це => (читається як «стрілка» або «переходить у»). Він відділяє вхідні параметри від тіла методу.

Базовий синтаксис лямбда-виразу

Припустімо, у вас є делегат (посилання на метод), і ви передаєте його у метод Sort():

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

students.Sort(CompareStudentsByAge); // Передаємо метод CompareStudentsByAge як параметр.

Є спосіб записати це коротше:

// Передаємо анонімний метод як параметр.
students.Sort( (Student student1, Student student2) => student1.Age.CompareTo(student2.Age) );

Тут ми замість імені методу підставляємо дві його ключові складові:

• параметри: (Student student1, Student student2)
• тіло методу: student1.Age.CompareTo(student2.Age)

Такий компактний запис методу і називається лямбда-виразом: (параметри) => вираз

Як це працює

Компілятор C#, коли зустрічає у коді лямбда-вираз, згенерує для нього справжній метод.

Припустімо, у вас є такий код:

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

Результат компіляції буде приблизно таким:

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

students.Sort( CompareStudents_Lambda123 );

4. Приклад сортування та лямбда-вирази

Перепишімо наш приклад зі студентами, використовуючи лямбда-вираз:

public class Program
{
    public static void Main(string[] args)
    {
        List<Student> students = new List<Student>
        {
            new Student("Іван", "Петренко", 20, 4.5),
            new Student("Марія", "Сидоренко", 22, 4.8),
            new Student("Олексій", "Іваненко", 19, 3.9),
            new Student("Олена", "Козловська", 20, 4.2)
        };

        Console.WriteLine("— Список студентів до сортування —");        
        foreach (var s in students)
            s.PrintInfo();

        // Тепер логіка порівняння написана прямо тут, «на місці».
        Console.WriteLine("— Сортуємо студентів за віком (використовуючи лямбда-вираз) —");
        students.Sort((student1, student2) => student1.Age.CompareTo(student2.Age));

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

        // Щоб відсортувати за спаданням, достатньо інвертувати порівняння.
        Console.WriteLine("\n— Сортуємо студентів за середнім балом (за спаданням) —");
        // s2.CompareTo(s1) замість s1.CompareTo(s2)
        students.Sort((s1, s2) => s2.AverageGrade.CompareTo(s1.AverageGrade));

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

Що тут відбулося?

1. students.Sort((student1, student2) => student1.Age.CompareTo(student2.Age));
   • student1 і student2 — це параметри, які Sort передаватиме нашому анонімному методу (аналогічно x і y у Comparison<T>).
   • => — це лямбда-оператор.
   • student1.Age.CompareTo(student2.Age) — це тіло лямбда-виразу. У цьому випадку це лише один вираз, результат якого і є значенням, що повертається.
2. Для сортування за середнім балом за спаданням ми просто поміняли місцями s1 і s2 у CompareTo. Це класичний трюк для інвертування порядку сортування.

Чому це зручно?

• Компактність: Не потрібно створювати окремі методи чи класи для кожної дрібної логіки порівняння.
• Читабельність: Логіка порівняння знаходиться поруч із викликом Sort(), що покращує розуміння коду, особливо для простих випадків.
• Гнучкість: Можна легко змінювати умови сортування «на льоту».

5. Делегати й лямбди — ідеальна пара

Може виникнути запитання: лямбда‑вираз — це те саме, що й делегат, чи щось інше?

Насправді лямбда-вираз — це лише синтаксичний цукор (syntax sugar) для створення екземпляра делегата або дерева виразів (Expression Tree, про це пізніше). Коли компілятор бачить лямбда-вираз, він «під капотом» перетворює його на екземпляр відповідного делегата. У нашому випадку, оскільки List<T>.Sort() очікує делегат Comparison<T>, компілятор розуміє, що (student1, student2) => student1.Age.CompareTo(student2.Age) потрібно перетворити саме на Comparison<Student>.

Отже, лямбда-вирази дозволяють писати дуже лаконічний код, а делегати — це ті «контейнери», що цей код переносять і дають змогу його виконувати. Вони працюють пліч-о‑пліч!

Коли що використовувати?

• IComparable<T>: Використовуйте, коли ваш тип має природний, очевидний спосіб сортування. Наприклад, якщо ви сортуєте товари, і основний спосіб — за їх артикулом. Цей інтерфейс визначає порядок «за замовчуванням».
• IComparer<T>: Використовуйте, коли потрібна багаторазова, перевикористовувана логіка порівняння, але ви не хочете «засмічувати» основний клас або коли існує кілька різних способів сортування. Наприклад, один IComparer для сортування товарів за ціною, інший — за назвою; ви застосовуєте їх у різних частинах застосунку.
• Делегати (Comparison<T>) і лямбда-вирази: Ідеальні для одноразових, ad‑hoc сортувань, коли логіка порівняння проста і не потребує окремого перевикористовуваного класу. Це найпоширеніший і «чистий» спосіб для більшості задач сортування у C#. Також це чудовий спосіб передавати логіку в інші методи, наприклад, у методи фільтрації (Find, FindAll) або пошуку (FindIndex), які ми розглядали раніше.

someList.Sort()

someList.Sort(new MyComparer())

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

6. Практичне застосування та погляд у майбутнє

Лямбда-вирази — це не просто «синтаксичний цукор» для сортування. Це потужний інструмент, який використовують повсюдно у сучасному коді на C#. Ви часто їх бачитимете:

• У LINQ (Language Integrated Query): Це, мабуть, наймасовіше застосування лямбда-виразів. LINQ дозволяє писати SQL‑подібні запити до колекцій, і лямбди використовують для визначення умов фільтрації, сортування, проєкції даних. Невдовзі ми вивчатимемо LINQ, і ви побачите, як лямбди роблять його неймовірно потужним і зручним.
• В обробці подій: Лямбди дають змогу лаконічно описувати, що має відбутися за певної події (наприклад, натисканні кнопки в інтерфейсі користувача).
• В асинхронному програмуванні: Для визначення задач, які мають виконуватися паралельно.
• У різних API .NET: Багато методів у стандартній бібліотеці .NET приймають делегати (і, відповідно, лямбда-вирази) як параметри для додавання гнучкої логіки.

Отже, опанувавши лямбда-вирази, ви не лише покращите свої навички сортування, а й зробите величезний крок до розуміння сучасного коду на C# та бібліотек. Це навичка, яку оцінять на будь-якій співбесіді і яка стане у пригоді в кожному проєкті!

7. Типові помилки і нюанси

Коли ви працюєте з делегатами й лямбда-виразами для порівняння, є кілька моментів, на які варто звернути увагу:

Неправильний результат порівняння: Пам’ятайте, що CompareTo або ваша логіка порівняння мають повертати від’ємне число, нуль або додатне число. Якщо ви випадково повернете щось інше, сортування може працювати некоректно або навіть призвести до помилок. Найчастіша помилка — коли новачки повертають true або false замість int. Метод Sort очікує саме числовий результат, оскільки йому потрібна інформація не лише про те, чи рівні елементи, а й про те, який із них «більший».

Обробка null значень: Якщо елементи у вашій колекції можуть бути null, то спроба викликати метод на null‑об’єкті (наприклад, student1.Age.CompareTo(...), якщо student1 дорівнює null) призведе до NullReferenceException. У таких випадках ваша логіка порівняння має явно обробляти null-значення. За загальним правилом, null вважається «менше» будь-якого ненульового значення. Якщо обидва — null, вони рівні. Якщо один — null, а інший — ні, null «менше».

// Приклад обробки null у лямбда-виразі для порівняння
students.Sort((s1, s2) => {
    if (s1 == null && s2 == null) return 0;
    if (s1 == null) return -1; // null менше всього
    if (s2 == null) return 1;  // не null більше null
    return s1.Age.CompareTo(s2.Age); // Порівнюємо, якщо обидва не null
});

На щастя, у реальних проєктах колекції часто не містять null, проте варто пам’ятати про цей момент!

Продуктивність: Хоча лямбда-вирази дуже зручні, інколи їх надмірне використання всередині «гарячих» циклів або для дуже великих колекцій може трохи вплинути на продуктивність порівняно з високооптимізованими класами IComparer, які, можливо, були ретельно протестовані й профільовані. Однак для більшості повсякденних завдань різниця буде незначною, а вигода у читабельності та простоті коду значно переважає.

Складні ланцюжки порівнянь: Якщо ви сортуєте спочатку за прізвищем, а потім за ім’ям, лямбда-вирази дозволяють вкладати кілька умов. Це набагато зручніше, ніж писати десять if в одному рядку! Головне — завжди спочатку перевіряти результат першого порівняння (lastNameComparison != 0), а лише тоді переходити до наступного рівня вкладеності.

Лямбда-вирази й делегати — це фундаментальні концепції у C#, які відкривають двері до більш гнучкого та функціонального стилю програмування. Їх розуміння і вміння застосовувати зроблять ваш код значно чистішим, ефективнішим і сучаснішим. Продовжуйте експериментувати — і зовсім скоро ви використовуватимете їх автоматично!