Mastering Multi-Sorting in C# with ThenBy() and ThenByDescending()

Sorting data in C# is straightforward with LINQ’s OrderBy() method. But what if you need to sort by multiple criteria? This is where ThenBy() and ThenByDescending() come in handy. In this post, we’ll dive into the essentials of multi-sorting in C#, along with practical examples that you can apply in real-world scenarios.

Understanding ThenBy() and ThenByDescending()

When you need to sort a list or collection by more than one property, you start with OrderBy() and add further sorting levels with ThenBy() or ThenByDescending(). The main difference is:

• ThenBy() sorts in ascending order.
• ThenByDescending() sorts in descending order.

Example 1: Sorting Employees by Department and Last Name

Imagine a scenario where you want to sort employees first by department, then by last name within each department:

class Employee
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Department { get; set; }
}

var employees = new List<Employee>
{
    new Employee { FirstName = "Alice", LastName = "Johnson", Department = "HR" },
    new Employee { FirstName = "Bob", LastName = "Smith", Department = "IT" },
    new Employee { FirstName = "Charlie", LastName = "Brown", Department = "HR" },
    new Employee { FirstName = "David", LastName = "Jones", Department = "IT" },
    new Employee { FirstName = "Eve", LastName = "White", Department = "Finance" }
};

var sortedEmployees = employees
    .OrderBy(e => e.Department)
    .ThenBy(e => e.LastName);

Finance: White, Eve
HR: Brown, Charlie
HR: Johnson, Alice
IT: Jones, David
IT: Smith, Bob

Example 2: Sorting Products by Category and Price

Let’s say you’re working with products and want to sort them first by category, then by price:

class Product
{
    public string Name { get; set; }
    public string Category { get; set; }
    public decimal Price { get; set; }
}

var products = new List<Product>
{
    new Product { Name = "Laptop", Category = "Electronics", Price = 999.99M },
    new Product { Name = "Headphones", Category = "Electronics", Price = 199.99M },
    new Product { Name = "Banana", Category = "Groceries", Price = 0.99M },
    new Product { Name = "Apple", Category = "Groceries", Price = 1.49M },
    new Product { Name = "Desk", Category = "Furniture", Price = 149.99M }
};

var sortedProducts = products
    .OrderBy(p => p.Category)
    .ThenBy(p => p.Price);

Electronics: Headphones - $199.99
Electronics: Laptop - $999.99
Furniture: Desk - $149.99
Groceries: Banana - $0.99
Groceries: Apple - $1.49

Example 3: Complex Sorting with Multiple Criteria

Now, let’s move on to a more complex example: sorting orders by customer name, order date, and order value (in descending order):

class Order
{
    public string CustomerName { get; set; }
    public DateTime OrderDate { get; set; }
    public decimal OrderValue { get; set; }
}

var orders = new List<Order>
{
    new Order { CustomerName = "Alice", OrderDate = new DateTime(2024, 8, 1), OrderValue = 250.50M },
    new Order { CustomerName = "Bob", OrderDate = new DateTime(2024, 8, 3), OrderValue = 300.00M },
    new Order { CustomerName = "Alice", OrderDate = new DateTime(2024, 8, 1), OrderValue = 100.00M },
    new Order { CustomerName = "Charlie", OrderDate = new DateTime(2024, 7, 25), OrderValue = 500.00M },
    new Order { CustomerName = "Bob", OrderDate = new DateTime(2024, 8, 3), OrderValue = 150.00M }
};

var sortedOrders = orders
    .OrderBy(o => o.CustomerName)
    .ThenBy(o => o.OrderDate)
    .ThenByDescending(o => o.OrderValue);

Alice: 8/1/2024, Value: $250.50
Alice: 8/1/2024, Value: $100.00
Bob: 8/3/2024, Value: $300.00
Bob: 8/3/2024, Value: $150.00
Charlie: 7/25/2024, Value: $500.00

Example 4: Sorting Books by Genre,Then by Author’s Last Name, Then by Publication Year

Books are sorted by genre (e.g., Fiction, Non-Fiction),then by the author’s last name, and finally bythe publication year in descending order (most recent books first).

class Book
{
    public string Title { get; set; }
    public string Genre { get; set; }
    public string AuthorLastName { get; set; }
    public int PublicationYear { get; set; }
}
var books = new List<Book>
{
    new Book { Title = "Book A", Genre = "Fiction",  AuthorLastName = "Smith",  PublicationYear = 2010 },
    new Book { Title = "Book B", Genre = "Non-Fiction",  AuthorLastName = "Jones",  PublicationYear = 2015 },
    new Book { Title = "Book C", Genre = "Fiction", AuthorLastName = "Brown", PublicationYear = 2012 },
    new Book { Title = "Book D", Genre = "Non-Fiction", AuthorLastName = "Johnson", PublicationYear = 2010 },
    new Book { Title = "Book E", Genre = "Fiction", AuthorLastName = "Smith", PublicationYear = 2005 }
};

var sortedBooks = books
    .OrderBy(b => b.Genre)
    .ThenBy(b => b.AuthorLastName)
    .ThenByDescending(b => b.PublicationYear);

Fiction: Book C by Brown, Published: 2012
Fiction: Book A by Smith, Published: 2010
Fiction: Book E by Smith, Published: 2005
Non-Fiction: Book D by Johnson, Published: 2010
Non-Fiction: Book B by Jones, Published: 2015

Why Multi-Sorting Matters

Multi-sorting is useful in scenarios where data needs to be arranged based on layered criteria. Whether you’re dealing with lists of students, employees, or products, ThenBy() allows you to control the sorting behavior effectively and accurately.

Wrapping Up

With OrderBy(), ThenBy(), and ThenByDescending(), you can perform layered sorting in C# with ease. These techniques are not only powerful but also simple to implement, making your code more readable and maintainable.