How to Sort a List<T> by a Property in the Object in C#

Sorting a List<T> by a property in C# is a common requirement, especially when working with collections of objects. Whether you want to sort by a single property or multiple properties, C# provides flexible options using methods like LINQ OrderBy, Comparison delegates, and IComparer. In this article, we’ll explore various approaches to sort a generic list in C#.

Why Sort a List by Property in C#?

Sorting a list makes it easier to organize and retrieve data. For example, you may need to sort a list of employees by their names or salaries in ascending or descending order. Using C#'s List sorting features, you can efficiently achieve this with minimal code.

Using LINQ OrderBy for List<T> Sorting

One of the easiest ways to sort a list is by using LINQ's OrderBy and OrderByDescending methods. LINQ is highly readable and concise, making it ideal for sorting operations.

Example: Sorting by a Single Property

📄

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

class Employee
{
    public string Name { get; set; }
    public int Age { get; set; }
}

class Program
{
    static void Main()
    {
        List employees = new List
        {
            new Employee { Name = "Alice", Age = 30 },
            new Employee { Name = "Bob", Age = 25 },
            new Employee { Name = "Charlie", Age = 35 }
        };

        var sortedEmployees = employees.OrderBy(e => e.Age).ToList();

        foreach (var employee in sortedEmployees)
        {
            Console.WriteLine($"{employee.Name}, {employee.Age}");
        }
    }
}

Example: Sorting in Descending Order

📄

var sortedEmployees = employees.OrderByDescending(e => e.Age).ToList();

This code sorts employees by age in descending order.

Using List.Sort with Comparison Delegates

The List.Sort method can be used for in-place sorting with a custom comparison logic.

Example: Sorting by a Property Using List.Sort

📄

employees.Sort((x, y) => x.Age.CompareTo(y.Age));

foreach (var employee in employees)
{
    Console.WriteLine($"{employee.Name}, {employee.Age}");
}

Sorting with IComparer Interface

For more complex sorting scenarios, you can implement the IComparer<T> interface to define custom sorting logic.

Example: Custom Comparer

📄

class EmployeeComparer : IComparer
{
    public int Compare(Employee x, Employee y)
    {
        return x.Age.CompareTo(y.Age);
    }
}

class Program
{
    static void Main()
    {
        employees.Sort(new EmployeeComparer());

        foreach (var employee in employees)
        {
            Console.WriteLine($"{employee.Name}, {employee.Age}");
        }
    }
}

Sorting by Multiple Properties

You can sort by multiple properties using LINQ's ThenBy and ThenByDescending methods.

Example: Sorting by Age and Name

📄

var sortedEmployees = employees
    .OrderBy(e => e.Age)
    .ThenBy(e => e.Name)
    .ToList();

foreach (var employee in sortedEmployees)
{
    Console.WriteLine($"{employee.Name}, {employee.Age}");
}

Comparison of Sorting Methods

FAQs

What is the difference between OrderBy and List.Sort?

OrderBy creates a new sorted list and is part of LINQ, while List.Sort modifies the original list in place. OrderBy is generally more readable, whereas List.Sort is faster for in-place sorting.

How can I sort a generic list in descending order?

Use OrderByDescending or pass a custom comparison delegate to List.Sort.

Can I sort a List<T> by multiple properties?

Yes, you can use ThenBy and ThenByDescending methods in LINQ for multi-property sorting.

When should I use IComparer?

Use IComparer when you need reusable and highly customized sorting logic.

Conclusion

Sorting a List<T> by a property in C# is straightforward, thanks to built-in methods like LINQ OrderBy and List.Sort. Depending on your use case, you can choose between simple LINQ queries, in-place sorting with List.Sort, or custom sorting logic with IComparer. Understanding these methods will help you write cleaner and more efficient code for your sorting needs.