Sorting Lists with LINQ and Lambda Expressions in C#

Introduction

Sorting lists of data is a fundamental operation in programming. C# provides several ways to achieve this, but leveraging LINQ (Language Integrated Query) and lambda expressions offers a concise and powerful approach. This tutorial will guide you through sorting lists, both in-place and by creating new sorted lists, using these features.

Understanding LINQ and Lambda Expressions

LINQ introduces a unified way to query data from various sources, including lists, arrays, and databases. Lambda expressions are anonymous functions that can be defined inline, making code more readable and compact. They are particularly useful when working with LINQ.

Sorting a List – Creating a New Sorted List

Often, you’ll want to create a new list that contains the sorted elements of an existing list, leaving the original list unchanged. The OrderBy() method from LINQ is ideal for this.

Here’s how it works:

using System.Collections.Generic;
using System.Linq;

public class Person
{
    public string LastName { get; set; }
    public string FirstName { get; set; }
}

public class Example
{
    public static void Main(string[] args)
    {
        List<Person> people = new List<Person>()
        {
            new Person { FirstName = "John", LastName = "Doe" },
            new Person { FirstName = "Jane", LastName = "Smith" },
            new Person { FirstName = "Peter", LastName = "Jones" }
        };

        // Sort the list by last name (ascending) and create a new list.
        var sortedPeople = people.OrderBy(person => person.LastName).ToList();

        // Now sortedPeople contains a new list with people sorted by LastName.
        // The original 'people' list remains unchanged.

        foreach (var person in sortedPeople)
        {
            Console.WriteLine($"{person.FirstName} {person.LastName}");
        }
    }
}

Explanation:

• people.OrderBy(person => person.LastName): This part uses the OrderBy() method to sort the people list. The person => person.LastName is a lambda expression that defines the sorting key. It takes a Person object as input (person) and returns the value of its LastName property. This tells OrderBy() to sort based on the LastName.
• .ToList(): This is crucial. OrderBy() returns an IOrderedEnumerable<Person>, not a List<Person>. Calling .ToList() converts the ordered result back into a List<Person>, allowing you to work with it as a standard list. If you don’t need a List specifically (e.g., you only need to iterate), you can omit .ToList().

Sorting a List In-Place

If you need to modify the original list directly (sort it in-place), you can use the Sort() method. However, Sort() requires a comparison delegate or an IComparer<T>. A lambda expression provides a convenient way to define this comparison.

using System.Collections.Generic;

public class Person
{
    public string LastName { get; set; }
    public string FirstName { get; set; }
}

public class Example
{
    public static void Main(string[] args)
    {
        List<Person> people = new List<Person>()
        {
            new Person { FirstName = "John", LastName = "Doe" },
            new Person { FirstName = "Jane", LastName = "Smith" },
            new Person { FirstName = "Peter", LastName = "Jones" }
        };

        // Sort the list in-place by last name.
        people.Sort((x, y) => string.Compare(x.LastName, y.LastName));

        // The 'people' list is now sorted directly.

        foreach (var person in people)
        {
            Console.WriteLine($"{person.FirstName} {person.LastName}");
        }
    }
}

Explanation:

• people.Sort((x, y) => string.Compare(x.LastName, y.LastName)): This line uses the Sort() method to sort the people list in-place.
• (x, y) => string.Compare(x.LastName, y.LastName): This is a lambda expression that defines the comparison logic. It takes two Person objects (x and y) as input and returns an integer value:
  • Negative if x should come before y.
  • Zero if x and y are equal.
  • Positive if x should come after y.
  • string.Compare is a built-in method that provides a reliable way to compare strings.

Sorting in Descending Order

To sort in descending order, you can use the OrderByDescending() method (to create a new list) or Sort() with a modified comparison logic.

// Create a new list sorted in descending order by last name
var sortedPeopleDescending = people.OrderByDescending(person => person.LastName).ToList();

// Sort in-place in descending order
people.Sort((x, y) => string.Compare(y.LastName, x.LastName)); // Note the reversed order

Best Practices and Considerations

• Immutability: When possible, favor creating new sorted lists using OrderBy() or OrderByDescending() to avoid modifying the original data. This promotes immutability and can make your code more predictable.
• Performance: For very large lists, in-place sorting with Sort() might be slightly more efficient, as it avoids creating a new list. However, the difference is often negligible for most use cases.
• Complex Sorting: You can chain multiple OrderBy() or ThenBy() calls to sort by multiple criteria.
• Custom Comparers: For more complex sorting logic, consider creating a custom IComparer<T> implementation instead of relying on lambda expressions. This can improve code organization and reusability.