LINQ Mastery

ThenBy: Multi-level sorting

1 Views Updated 5/4/2026

Secondary Sorting

What happens when two items have the same 'Primary' key? ThenBy allows you to specify subsequent sorting criteria.

1. Why NOT use another OrderBy?

A common mistake is calling .OrderBy(x => x.A).OrderBy(x => x.B). This actually throws away the first sort and re-sorts the entire list by B. To maintain the primary sort, you MUST use ThenBy.


// Correct way: Sort by LastName, then by FirstName
var sortedUsers = users.OrderBy(u => u.LastName)
                       .ThenBy(u => u.FirstName);
    

2. Infinite Levels

You can chain as many ThenBy or ThenByDescending calls as you need. C# handles the priority from left to right. This is essential for building complex data tables with multi-column sorting.

3. Architect Insight

Q: "Do multiple levels of sorting impact performance?"

Architect Answer: "Yes, each level adds a small amount of comparison logic. However, the biggest impact is on the database. In SQL, this becomes ORDER BY A, B, C. Ensure your DB composite indexes match your most common multi-column search patterns to keep queries optimized."

LINQ Mastery
General
Introduction to LINQ Mastery
1. Core Foundations
LINQ Fundamentals: Why LINQ? IQueryable vs IEnumerable: The Architect's choice Expression Trees: The power behind LINQ providers Method Syntax vs Query Syntax: Trade-offs
2. Filtering & Transformation
Where & Select: The bread and butter SelectMany: Flattening complex hierarchies OfType vs Cast: Handling heterogeneous collections Distinct & DistinctBy: Mastering unique sets
3. Aggregation & Quantifiers
Any, All, Contains: The boolean quantifiers Count, LongCount, Sum: Basic aggregations Min, Max, Average: Statistical operations Aggregate: The 'Fold' function of .NET
4. Ordering & Partitioning
OrderBy & OrderByDescending: Sorting data ThenBy: Multi-level sorting Take & Skip: Pagination strategies TakeWhile & SkipWhile: Dynamic partitioning
5. Sets & Lookups
Union, Intersect, Except: Set theory in C# Zip: Combining two streams ToDictionary vs ToLookup: One-to-One vs One-to-Many Chunk: Slicing data for batch processing
6. Join & Grouping
Inner Join: The standard match GroupJoin: Creating hierarchical results GroupBy: The SQL counterpart in LINQ Left Outer Join: The manual workaround in LINQ
7. Advanced Providers & Parallelism
PLINQ (Parallel LINQ): Speeding up CPU-bound queries AsParallel vs AsSequential: When to switch LINQ to XML: Processing documents with ease Custom LINQ Providers: How to build your own 'Queryable'
8. Real-world Performance & Patterns
Memory Leaks in LINQ: Capturing variables and closures Architect Case Study: Optimizing a multi-join dashboard query