Enumerable.OrderBy() / OrderByDescending()

using System.Linq;

// Sort in ascending order.
IOrderedEnumerable<T> asc = source.OrderBy(x => key);

// Sort in descending order.
IOrderedEnumerable<T> desc = source.OrderByDescending(x => key);

// Add a second and third sort key (chain after OrderBy).
IOrderedEnumerable<T> multi = source.OrderBy(x => key1)
                                     .ThenBy(x => key2)
                                     .ThenByDescending(x => key3);

Program.cs

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

List<int> numbers = new List<int> { 5, 1, 8, 3, 9, 2 };

// Sort in ascending order.
IEnumerable<int> asc = numbers.OrderBy(n => n);
Console.WriteLine(string.Join(", ", asc)); // 1, 2, 3, 5, 8, 9

// Sort in descending order.
IEnumerable<int> desc = numbers.OrderByDescending(n => n);
Console.WriteLine(string.Join(", ", desc)); // 9, 8, 5, 3, 2, 1

// Sort a list of objects by a property.
var fighters = new List<(string Name, int Age)>
{
    ("Terry Bogard", 24),
    ("Kusanagi Kyo", 20),
    ("Yagami Iori", 20),
    ("Blue Mary", 23),
};

// Sort by age in ascending order.
var byAge = fighters.OrderBy(f => f.Age);
foreach (var f in byAge)
    Console.WriteLine($"{f.Name}: {f.Age}");

// Sort by age ascending; break ties by name ascending.
var byAgeAndName = fighters.OrderBy(f => f.Age)
                             .ThenBy(f => f.Name);
foreach (var f in byAgeAndName)
    Console.WriteLine($"{f.Name}: {f.Age}");

// Sort strings by length descending; break ties alphabetically.
List<string> names = new List<string> { "Goenitz", "Yagami Iori", "Blue Mary", "Kusanagi Kyo", "Terry Bogard" };
var sorted = names.OrderByDescending(n => n.Length).ThenBy(n => n);
Console.WriteLine(string.Join(", ", sorted)); // Kusanagi Kyo, Terry Bogard, Yagami Iori, Blue Mary, Goenitz

Run the following command:

dotnet run
1, 2, 3, 5, 8, 9
9, 8, 5, 3, 2, 1
Kusanagi Kyo: 20
Yagami Iori: 20
Blue Mary: 23
Terry Bogard: 24
Kusanagi Kyo: 20
Yagami Iori: 20
Blue Mary: 23
Terry Bogard: 24
Kusanagi Kyo, Terry Bogard, Yagami Iori, Blue Mary, Goenitz

Common Mistake: Chaining Another OrderBy() After OrderBy() Discards the First Sort

Calling OrderBy() again after an existing OrderBy() completely replaces the previous sort. Always use ThenBy() when sorting by multiple keys.

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

var fighters = new List<(string Name, int Age)>
{
    ("Kusanagi Kyo", 20), ("Yagami Iori", 20), ("Terry Bogard", 24)
};

// NG: chaining OrderBy() again discards the first sort
var wrong = fighters.OrderBy(f => f.Age).OrderBy(f => f.Name);
foreach (var f in wrong) Console.WriteLine($"{f.Name}: {f.Age}");
Console.WriteLine("---");

// OK: use ThenBy() for a secondary sort key
var correct = fighters.OrderBy(f => f.Age).ThenBy(f => f.Name);
foreach (var f in correct) Console.WriteLine($"{f.Name}: {f.Age}");

Run the following command:

dotnet run
Kusanagi Kyo: 20
Terry Bogard: 24
Yagami Iori: 20
---
Kusanagi Kyo: 20
Yagami Iori: 20
Terry Bogard: 24

The OrderBy() family of methods performs a stable sort. This means elements that share the same key value retain their original relative order.

Chaining another OrderBy() call after an existing OrderBy() discards the previous sort. Always use ThenBy() when you need to sort by multiple keys. Also, sorting returns a new sequence and does not modify the original collection.

To retrieve the first or last element after sorting, see Enumerable.First() / Last(). To sort within groups, combine this method with Enumerable.GroupBy().