How to sort a list of objects by property in C#

List<Person> people =
[
    new("Grace", 45, 1.68m, new DateOnly(2021, 3, 14)),
    new("Ada", 36, 1.65m, new DateOnly(2019, 11, 2)),
    new("Linus", 28, 1.80m, new DateOnly(2023, 6, 30)),
    new("Barbara", 52, 1.72m, new DateOnly(2018, 1, 9)),
];

// By a string property: OrderBy takes a key selector and returns a new sequence
List<Person> byName = people.OrderBy(p => p.Name).ToList();
Console.WriteLine(string.Join(", ", byName.Select(p => p.Name)));
Console.WriteLine(byName[0]);

// The source list is untouched
Console.WriteLine(string.Join(", ", people.Select(p => p.Name)));

// By a number, ascending and descending
Console.WriteLine(string.Join(", ", people.OrderBy(p => p.Age).Select(p => p.Name)));
Console.WriteLine(string.Join(", ", people.OrderByDescending(p => p.Height).Select(p => p.Name)));

// By a date: DateOnly, DateTime, decimal, enums... any comparable key works
foreach (Person p in people.OrderBy(p => p.Joined))
{
    Console.WriteLine($"{p.Joined:yyyy-MM-dd} {p.Name}");
}

// To "sort the list itself" with LINQ, assign the result back
people = people.OrderBy(p => p.Age).ToList();
Console.WriteLine(people[0].Name);

record Person(string Name, int Age, decimal Height, DateOnly Joined);

List<Person> people =
[
    new("Grace", 45),
    new("Ada", 36),
    new("Linus", 28),
    new("Barbara", 52),
];

// In place: List<T>.Sort takes a Comparison<T>, a (a, b) => int lambda
people.Sort((a, b) => a.Age.CompareTo(b.Age));
Console.WriteLine(string.Join(", ", people.Select(p => p.Name)));

// Descending: swap a and b
people.Sort((a, b) => b.Age.CompareTo(a.Age));
Console.WriteLine(string.Join(", ", people.Select(p => p.Name)));

// Strings: pick the comparison explicitly
people.Sort((a, b) => string.Compare(a.Name, b.Name, StringComparison.Ordinal));
Console.WriteLine(string.Join(", ", people.Select(p => p.Name)));

// A reusable IComparer<T> from a lambda (for Sort, BinarySearch, SortedSet...)
IComparer<Person> byAge = Comparer<Person>.Create((a, b) => a.Age.CompareTo(b.Age));
people.Sort(byAge);
Console.WriteLine(string.Join(", ", people.Select(p => p.Name)));

// List<T>.Sort is NOT stable: equal keys can swap places
List<Person> ties = [new("first", 30), new("second", 30), new("third", 20)];
ties.Sort((a, b) => a.Age.CompareTo(b.Age));
Console.WriteLine("Sort:    " + string.Join(", ", ties.Select(p => p.Name)));

List<Person> ties2 = [new("first", 30), new("second", 30), new("third", 20)];
Console.WriteLine("OrderBy: " + string.Join(", ", ties2.OrderBy(p => p.Age).Select(p => p.Name)));

record Person(string Name, int Age);

List<Player> players =
[
    new("dana", "blue", 90),
    new("alice", "red", 90),
    new("carol", "red", 70),
    new("bob", "blue", 70),
];

// Score high to low, then name A-Z when the scores tie
foreach (var p in players.OrderByDescending(p => p.Score).ThenBy(p => p.Name))
{
    Console.WriteLine($"{p.Score} {p.Name}");
}

Console.WriteLine("--");

// Team A-Z, then score high to low
foreach (var p in players.OrderBy(p => p.Team).ThenByDescending(p => p.Score))
{
    Console.WriteLine($"{p.Team} {p.Score} {p.Name}");
}

Console.WriteLine("--");

// Careful: a second OrderBy starts a new sort; it does not add a tie-breaker
foreach (var p in players.OrderBy(p => p.Team).OrderBy(p => p.Name))
{
    Console.WriteLine($"{p.Team} {p.Name}");
}

Console.WriteLine("--");

// The same two keys in place with List<T>.Sort: fall through to the next key on a tie
players.Sort((a, b) =>
{
    int byTeam = string.CompareOrdinal(a.Team, b.Team);
    return byTeam != 0 ? byTeam : b.Score.CompareTo(a.Score);
});
Console.WriteLine(string.Join(", ", players.Select(p => p.Name)));

record Player(string Name, string Team, int Score);

List<Contact> contacts =
[
    new("bob", "Oslo", 3),
    new("Alice", null, null),
    new("carol", "Berlin", 1),
    new("Dave", "Austin", null),
];

// Default string order is culture-aware, not by char code
Console.WriteLine(Names(contacts.OrderBy(c => c.Name)));

// Ordinal compares char codes: every capital before every lowercase letter
Console.WriteLine(Names(contacts.OrderBy(c => c.Name, StringComparer.Ordinal)));

// Ordinal and case-insensitive: fast and predictable for identifiers
Console.WriteLine(Names(contacts.OrderBy(c => c.Name, StringComparer.OrdinalIgnoreCase)));

// A null key does not throw: null sorts before every value
Console.WriteLine(string.Join(", ", contacts.OrderBy(c => c.City).Select(c => c.City ?? "null")));
Console.WriteLine(string.Join(", ", contacts.OrderBy(c => c.Rank).Select(c => c.Rank?.ToString() ?? "null")));

// Nulls last instead: sort on "is it null?" first, then on the value
Console.WriteLine(string.Join(", ", contacts
    .OrderBy(c => c.City is null)
    .ThenBy(c => c.City)
    .Select(c => c.City ?? "null")));

// A null element is different: the key selector itself throws
List<Contact?> withNull = [.. contacts, null];
try
{
    withNull.OrderBy(c => c!.Name).ToList();
}
catch (NullReferenceException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}

// Use ?. so the key is null for a null element
Console.WriteLine(string.Join(", ", withNull.OrderBy(c => c?.Name).Select(c => c?.Name ?? "null")));

static string Names(IEnumerable<Contact> list) => string.Join(", ", list.Select(c => c.Name));

record Contact(string Name, string? City, int? Rank);

List<Version> versions = [new(2, 0), new(1, 10), new(1, 2)];

// No comparer needed: Sort(), Order(), Max() and SortedSet all use CompareTo
versions.Sort();
Console.WriteLine(string.Join(", ", versions));
Console.WriteLine(string.Join(", ", versions.OrderDescending()));  // .NET 7+
Console.WriteLine(versions.Max());

// A type with no natural order fails at run time, not at compile time
List<Account> accounts = [new("A", 2_000_000_000), new("B", -2_000_000_000), new("C", 0)];
try
{
    accounts.Sort();
}
catch (InvalidOperationException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
    Console.WriteLine($"  inner: {e.InnerException?.Message}");
}

// The classic bug: a comparison that subtracts can overflow and flip the sign
accounts.Sort((a, b) => a.Balance - b.Balance);
Console.WriteLine(string.Join(", ", accounts.Select(a => a.Id)));
Console.WriteLine(unchecked(2_000_000_000 - -2_000_000_000));

// CompareTo never overflows
accounts.Sort((a, b) => a.Balance.CompareTo(b.Balance));
Console.WriteLine(string.Join(", ", accounts.Select(a => a.Id)));

// IComparable<T> gives the type one built-in "natural" order
record Version(int Major, int Minor) : IComparable<Version>
{
    public int CompareTo(Version? other)
    {
        if (other is null) return 1;
        int byMajor = Major.CompareTo(other.Major);
        return byMajor != 0 ? byMajor : Minor.CompareTo(other.Minor);
    }

    public override string ToString() => $"{Major}.{Minor}";
}

record Account(string Id, int Balance);

using System.Linq.Expressions;

List<Person> people =
[
    new("Grace", 45, "Arlington"),
    new("Ada", 36, "London"),
    new("Linus", 28, "Helsinki"),
];

// 1. A whitelist of allowed sort keys: safe for input from a query string
Dictionary<string, Func<Person, object>> sortKeys = new(StringComparer.OrdinalIgnoreCase)
{
    ["name"] = p => p.Name,
    ["age"] = p => p.Age,
    ["city"] = p => p.City,
};
string sortBy = "city";
if (sortKeys.TryGetValue(sortBy, out var key))
{
    Console.WriteLine(Names(people.OrderBy(key)));
}

// 2. Any property by name with reflection (IEnumerable only)
var prop = typeof(Person).GetProperty("Age")!;
Console.WriteLine(Names(people.OrderByDescending(p => prop.GetValue(p))));

// 3. An expression tree: works on IQueryable, so a database provider can translate it
IQueryable<Person> query = people.AsQueryable();
Console.WriteLine(Names(OrderByProperty(query, "Name")));
Console.WriteLine(Names(OrderByProperty(query, "Age", descending: true)));

try
{
    OrderByProperty(query, "Salary");
}
catch (ArgumentException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}

static IOrderedQueryable<T> OrderByProperty<T>(IQueryable<T> source, string property, bool descending = false)
{
    ParameterExpression x = Expression.Parameter(typeof(T), "x");
    MemberExpression body = Expression.Property(x, property);   // x => x.<property>
    LambdaExpression keySelector = Expression.Lambda(body, x);
    MethodCallExpression call = Expression.Call(
        typeof(Queryable),
        descending ? nameof(Queryable.OrderByDescending) : nameof(Queryable.OrderBy),
        [typeof(T), body.Type],
        source.Expression,
        Expression.Quote(keySelector));
    return (IOrderedQueryable<T>)source.Provider.CreateQuery<T>(call);
}

static string Names(IEnumerable<Person> list) => string.Join(", ", list.Select(p => p.Name));

record Person(string Name, int Age, string City);