Lambdas and Delegates for Comparison

1. Introduction

Imagine you have a list of students, and you need to sort them once by age, then by last name, then by average grade, but only for those who passed all exams. If you write a whole new class implementing IComparer<T> for each such "one-off" comparison, your project will quickly turn into a junkyard of tiny comparator classes. That's a pain: the code gets bulky and unreadable.

For these situations, C# offers a more elegant solution: the ability to pass comparison logic directly into the Sort method without creating a separate class.

For this, we'll need delegates and their compact siblings—lambda expressions.

Delegates – our flexible helpers

Before we jump into lambdas, let's figure out what a delegate is. In plain English, a delegate is a type that represents a reference to a method. Sounds a bit metaphysical, right? Think of it like this:

Imagine you have a to-do list, and some of those tasks are "instructions" or "recipes." A delegate is like a special variable that can store a reference to such a "recipe" (method). Then, when you need to do that task, you just call the delegate variable, and it "calls" the method it's pointing to.

In C#, delegates are used for creating callbacks (calling a method later, usually as a reaction to an event), handling events (reacting to actions like button clicks), and, of course, for passing methods as arguments to other methods (so a method can call another method), which is exactly what we need for sorting.

The List<T>.Sort() method has several overloads (versions), and one of them takes a special delegate called Comparison<T>.

2. The Comparison<T> Delegate

What is Comparison<T>?

Comparison<T> is a built-in .NET delegate, specifically designed for comparing two objects of the same type T. Its "recipe" looks like this: it takes two objects of type T as input (let's call them x and y) and returns an integer (int):

• Negative number (like -1) if x is "less than" y.
• Zero (0) if x is "equal to" y.
• Positive number (like 1) if x is "greater than" y.

This is exactly how IComparable.CompareTo and IComparer.Compare work. So, the logic is the same, but now we can pass it as a "method variable" instead of a separate class.

Let's look at an example. Back to our students. Suppose we have a Student class:

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}, Age: {Age}, Grade: {AverageGrade:F2}");
    }
}

Now, to sort a list of students by age using a delegate, we can write a separate static method that matches the Comparison<Student> signature:

public class Program
{
    // Method matching the Comparison<Student> delegate signature
    // It will compare two students by their age
    public static int CompareStudentsByAge(Student student1, Student student2)
    {
        // Use the built-in CompareTo method for numbers,
        // which returns -1, 0, or 1 depending on the comparison.
        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("Alexey", "Ivanov", 19, 3.9),
            new Student("Elena", "Kozlova", 20, 4.2) // Two students with the same age
        };

        Console.WriteLine("--- Student list before sorting ---");        
        foreach (var s in students)
            s.PrintInfo();

        Console.WriteLine("--- Sorting students by age (using delegate) ---");
        students.Sort(CompareStudentsByAge); //pass CompareStudentsByAge as parameter

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

Breaking down the code:

1. We created a static method CompareStudentsByAge that takes two students and returns an int, following the Comparison<Student> contract.
2. In Main we created a list of students.
3. When we call students.Sort(CompareStudentsByAge);, we're not calling CompareStudentsByAge() right away! We're just passing a reference to this method. List<T>.Sort() will then call our CompareStudentsByAge method as many times as it needs for sorting, passing it different pairs of students. It's a lot like giving someone a delivery address, not sending the whole truck there right away.

This approach is way more convenient than creating a separate comparator class for every little sort. But we can go even further!

3. Meet Lambda Expressions

Even having to write a separate method like CompareStudentsByAge can feel like overkill if the comparison logic is simple and only needed once or twice. For these cases, C# introduced lambda expressions.

What's a lambda expression? Basically, it's an anonymous method or, as I like to joke, a "homeless method." It's a way to write a short piece of code (a method) right where you need it, without declaring it separately. It's like jotting down instructions on a sticky note and slapping it right on the task, instead of writing a whole manual.

The main lambda expression operator is => (read as "arrow" or "goes to"). It separates the input parameters from the method body.

Basic Lambda Expression Syntax

Suppose you have a delegate (a method reference) and you pass it to the Sort() function:

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

students.Sort(CompareStudentsByAge); //pass CompareStudentsByAge as parameter

There's a shorter way to write this:

//pass an anonymous method as parameter
students.Sort( (Student student1, Student student2) => student1.Age.CompareTo(student2.Age) );

Here, instead of a method name, we just put its two most important things:

• parameters: (Student student1, Student student2)
• method body: student1.Age.CompareTo(student2.Age)

This compact method notation is called a lambda expression: (parameters) => expression

How it works

When the C# compiler sees a lambda expression in your code, it generates a real method for it.

Suppose you have this code:

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

The result after compilation will look something like:

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

students.Sort( CompareStudents_Lambda123 );

4. Sorting Example and Lambda Expressions

Let's rewrite our student example using a lambda expression:

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("Alexey", "Ivanov", 19, 3.9),
            new Student("Elena", "Kozlova", 20, 4.2)
        };

        Console.WriteLine("--- Student list before sorting ---");        
        foreach (var s in students)
            s.PrintInfo();

        // Now the comparison logic is written right here, "in place"
        Console.WriteLine("--- Sorting students by age (using lambda expression) ---");
        students.Sort((student1, student2) => student1.Age.CompareTo(student2.Age));

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

        // To sort in descending order, just multiply the result by -1
        Console.WriteLine("\n--- Sorting students by average grade (descending) ---");
        // s2.CompareTo(s1) instead of s1.CompareTo(s2)
        students.Sort((s1, s2) => s2.AverageGrade.CompareTo(s1.AverageGrade));

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

What happened here?

1. students.Sort((student1, student2) => student1.Age.CompareTo(student2.Age));
   • student1 and student2 are the parameters that Sort will pass to our anonymous method (just like x and y in Comparison<T>).
   • => is the lambda operator.
   • student1.Age.CompareTo(student2.Age) is the body of the lambda expression. In this case, it's just one expression, and its result is the return value.
2. To sort by average grade in descending order, we just swapped s1 and s2 in CompareTo. That's a classic trick to invert the sort order.

Why is this convenient?

• Compactness: No need to create separate methods or classes for every little comparison logic.
• Readability: The comparison logic is right next to the Sort() call, which makes the code easier to understand, especially for simple cases.
• Flexibility: You can easily change the sort conditions "on the fly."

5. Delegates and Lambdas – the perfect pair

You might wonder: so is a lambda expression the same as a delegate, or something else?

Actually, a lambda expression is just syntactic sugar for creating a delegate instance or an expression tree (more on that later). When the compiler sees a lambda expression, it automatically, "under the hood," turns it into an instance of the right delegate. In our case, since List<T>.Sort() expects a Comparison<T> delegate, the compiler knows that (student1, student2) => student1.Age.CompareTo(student2.Age) should be turned into a Comparison<Student>.

So, lambda expressions let us write super concise code, and delegates are the "containers" that carry and execute that code. They work hand in hand!

When should you use what?

• IComparable<T>: Use this when your type has a natural, obvious way to sort. For example, if you're sorting products and the main way is by their SKU. This interface defines the "default" order.
• IComparer<T>: Use this when you need multiple, reusable comparison logics, but you don't want to "clutter" the main class or when you have several different ways to sort. For example, one IComparer for sorting products by price, another by name, and you use them in different parts of your program.
• Delegates (Comparison<T>) and Lambda Expressions: Perfect for one-off, ad-hoc sorts, when the comparison logic is simple and doesn't need a reusable class. This is the most common and cleanest way for most sorting tasks in C#. It's also a great way to pass logic to other methods, like filtering methods (Find, FindAll) or search methods (FindIndex), which we covered earlier.

someList.Sort()

someList.Sort(new MyComparer())

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

6. Practical Use and Looking Ahead

Lambda expressions aren't just "syntactic sugar" for sorting. They're a powerful tool used everywhere in modern C# code. You'll see them all the time:

• In LINQ (Language Integrated Query): This is probably the most common use of lambda expressions. LINQ lets you write SQL-like queries for collections, and lambdas are used to define filter, sort, and projection conditions. We'll be learning LINQ soon, and you'll see how lambdas make it incredibly powerful and convenient.
• In event handling: Lambdas let you concisely describe what should happen on some event (like a button click in a UI).
• In async programming: For defining tasks that should run in parallel.
• In various .NET APIs: Tons of methods in the .NET standard library take delegates (and thus lambda expressions) as parameters to add flexible logic.

So, by mastering lambda expressions, you'll not only improve your sorting skills, but also take a huge step toward understanding modern C# code and libraries. It's a skill that'll be valued in any interview and useful in every project!

7. Common Mistakes and Nuances

When working with delegates and lambda expressions for comparison, there are a few things to watch out for:

Wrong comparison result: Remember, CompareTo or your comparison logic should return a negative number, zero, or a positive number. If you accidentally return something else, sorting might work incorrectly or even throw errors. The most common mistake—beginners return true or false instead of int. The Sort method expects a numeric result, because it needs to know not just if elements are equal, but which one is "greater."

Handling null values: If your collection can have null elements, trying to call a method on a null object (like student1.Age.CompareTo(...) if student1 is null) will throw a NullReferenceException. In these cases, your comparison logic should explicitly handle null values. The general rule: null is considered "less than" any non-null value. If both are null, they're equal. If one is null and the other isn't, null is "less."

// Example of handling null in a lambda expression for comparison
students.Sort((s1, s2) => {
    if (s1 == null && s2 == null) return 0;
    if (s1 == null) return -1; // null is less than anything
    if (s2 == null) return 1;  // non-null is greater than null
    return s1.Age.CompareTo(s2.Age); // Compare if both are not null
});

Luckily, in real projects, collections often don't contain null, but it's super important to keep this in mind!

Performance: While lambda expressions are super convenient, sometimes using them too much inside really "hot" loops or for huge collections can slightly affect performance compared to highly-optimized IComparer classes that might have been carefully tested and profiled. But for most everyday tasks, the difference is negligible, and the gain in readability and code simplicity is way more important.

Complex comparison chains: As we saw in the example with sorting by last name, then by first name, lambda expressions let you nest multiple conditions. That's way more convenient than writing ten if statements in one line! The main thing—always check the result of the first comparison (lastNameComparison != 0) before moving to the next level of nesting.

Lambda expressions and delegates are fundamental concepts in C# that open the door to a more flexible and functional programming style. Understanding and using them will make your code way cleaner, more efficient, and modern. Keep experimenting, and soon you'll be using them automatically!

2

Task

C# SELF, level 30, lesson 2

Locked

Sorting numbers using a lambda expression

Sorting numbers using a lambda expression

Open