How to group by with LINQ in C#

List<Order> orders =
[
    new("alice", "books", 12.50m),
    new("bob", "games", 59.99m),
    new("alice", "games", 19.99m),
    new("carol", "books", 8.00m),
    new("bob", "books", 15.00m),
    new("alice", "music", 9.99m),
];

// GroupBy takes a key selector and returns IEnumerable<IGrouping<TKey, TElement>>.
IEnumerable<IGrouping<string, Order>> byCustomer = orders.GroupBy(o => o.Customer);

foreach (IGrouping<string, Order> group in byCustomer)
{
    // Each group has a Key and is itself a sequence of the matching items.
    Console.WriteLine($"{group.Key}: count={group.Count()}, total={group.Sum(o => o.Total)}");
    foreach (Order order in group)
    {
        Console.WriteLine($"  {order.Category,-6} {order.Total}");
    }
}

// Group by any expression, not just a property: here, small vs large orders.
foreach (var group in orders.GroupBy(o => o.Total >= 15m ? "large" : "small"))
{
    Console.WriteLine($"{group.Key}: {string.Join(", ", group.Select(o => o.Total))}");
}

record Order(string Customer, string Category, decimal Total);

List<Person> people =
[
    new(1, "Ferrari"),
    new(1, "BMW"),
    new(2, "Audi"),
    new(3, "Toyota"),
    new(2, "Volvo"),
];

// Key selector + element selector: each group holds only the cars.
foreach (IGrouping<int, string> g in people.GroupBy(p => p.PersonId, p => p.Car))
{
    Console.WriteLine($"{g.Key}: {string.Join(", ", g)}");
}

// Add a result selector to turn each group into a new shape in the same call.
var owners = people.GroupBy(
    p => p.PersonId,
    p => p.Car,
    (id, cars) => new { PersonId = id, Cars = cars.ToList() });
foreach (var owner in owners)
{
    Console.WriteLine($"person {owner.PersonId} owns {owner.Cars.Count}: [{string.Join(", ", owner.Cars)}]");
}

// The same result with GroupBy + Select, which many people find easier to read.
var sameThing = people
    .GroupBy(p => p.PersonId)
    .Select(g => new { PersonId = g.Key, Cars = g.Select(p => p.Car).ToList() })
    .ToList();
Console.WriteLine($"Select version: {sameThing.Count} owners, first owns {sameThing[0].Cars.Count}");

// Straight into a Dictionary<int, List<string>> for lookups by key.
Dictionary<int, List<string>> carsById = people
    .GroupBy(p => p.PersonId)
    .ToDictionary(g => g.Key, g => g.Select(p => p.Car).ToList());
Console.WriteLine($"carsById[2] = [{string.Join(", ", carsById[2])}]");

record Person(int PersonId, string Car);

List<Sale> sales =
[
    new("north", 2025, "widget", 120),
    new("south", 2025, "widget", 80),
    new("north", 2025, "gadget", 45),
    new("north", 2026, "widget", 150),
    new("south", 2025, "gadget", 60),
    new("north", 2025, "widget", 30),
];

// Anonymous type key: the classic way, works since C# 3.
foreach (var g in sales.GroupBy(s => new { s.Region, s.Year }))
{
    Console.WriteLine($"{g.Key.Region} {g.Key.Year}: {g.Sum(s => s.Units)} units");
}
Console.WriteLine(sales.GroupBy(s => new { s.Region, s.Year }).First().Key);

// Tuple key (C# 7+): the element names Region and Product are inferred.
foreach (var g in sales.GroupBy(s => (s.Region, s.Product)))
{
    Console.WriteLine($"{g.Key}: rows={g.Count()}, g.Key.Region={g.Key.Region}");
}

// Record key: value equality too, and a type you can return from a method.
var byRecord = sales.GroupBy(s => new RegionYear(s.Region, s.Year)).ToList();
Console.WriteLine($"record key: {byRecord.Count} groups, first is {byRecord[0].Key}");

// A plain class key does NOT group: two instances are never equal by default.
var byClass = sales.GroupBy(s => new RegionYearClass(s.Region, s.Year)).ToList();
Console.WriteLine($"class key: {byClass.Count} groups");

record Sale(string Region, int Year, string Product, int Units);
record RegionYear(string Region, int Year);

class RegionYearClass(string region, int year)
{
    public string Region { get; } = region;
    public int Year { get; } = year;
}

List<Student> students =
[
    new("Ana", "Red", 2, 88),
    new("Ben", "Blue", 1, 72),
    new("Cleo", "Red", 1, 95),
    new("Dev", "Green", 2, 64),
    new("Eli", "Blue", 2, 81),
    new("Fay", "Red", 2, 70),
];

// Query syntax: "group ... by ... into g" continues the query with each group.
var houses =
    from s in students
    group s by s.House into g
    orderby g.Key
    select new { House = g.Key, Count = g.Count(), Best = g.Max(s => s.Score) };

foreach (var h in houses)
{
    Console.WriteLine($"{h.House,-5} count={h.Count} best={h.Best}");
}

// Multiple columns: group by an anonymous type, and pick what goes in each group.
var byHouseYear =
    from s in students
    group s.Name by new { s.House, s.Year } into g
    orderby g.Key.House, g.Key.Year
    select $"{g.Key.House} year {g.Key.Year}: {string.Join(", ", g)}";

foreach (string line in byHouseYear)
{
    Console.WriteLine(line);
}

// Without "into", the query ends at the group clause and yields IGrouping objects.
IEnumerable<IGrouping<string, Student>> plain = from s in students group s by s.House;
Console.WriteLine(string.Join(" | ", plain.Select(g => $"{g.Key}:{g.Count()}")));

record Student(string Name, string House, int Year, int Score);

List<Order> orders =
[
    new("alice", "books", 12.50m),
    new("bob", "games", 59.99m),
    new("alice", "games", 19.99m),
    new("carol", "books", 8.00m),
    new("bob", "books", 15.00m),
    new("alice", "music", 9.99m),
    new("dana", "games", 24.00m),
];

// SELECT Category, COUNT(*), SUM(Total), AVG(Total) ... GROUP BY Category ORDER BY SUM DESC
var stats = orders
    .GroupBy(o => o.Category)
    .Select(g => new
    {
        Category = g.Key,
        Count = g.Count(),
        Sum = g.Sum(o => o.Total),
        Avg = Math.Round(g.Average(o => o.Total), 2),
        Biggest = g.MaxBy(o => o.Total)!.Customer,
    })
    .OrderByDescending(x => x.Sum);

foreach (var s in stats)
{
    Console.WriteLine($"{s.Category,-6} count={s.Count} sum={s.Sum} avg={s.Avg} biggest={s.Biggest}");
}

// HAVING: filter the groups with Where after GroupBy.
var repeatBuyers = orders
    .GroupBy(o => o.Customer)
    .Where(g => g.Count() > 1)
    .Select(g => g.Key);
Console.WriteLine($"more than one order: {string.Join(", ", repeatBuyers)}");

// .NET 9+: CountBy and AggregateBy skip the intermediate groups entirely.
// They return key-value pairs; sort them if the order matters.
foreach (var (category, count) in orders.CountBy(o => o.Category).OrderBy(p => p.Key))
{
    Console.WriteLine($"CountBy {category}: {count}");
}
foreach (var (customer, total) in orders.AggregateBy(o => o.Customer, 0m, (sum, o) => sum + o.Total).OrderBy(p => p.Key))
{
    Console.WriteLine($"AggregateBy {customer}: {total}");
}

record Order(string Customer, string Category, decimal Total);

List<string> files = ["notes.txt", "photo.JPG", "data.csv", "logo.png", "todo.TXT", "cat.jpg"];

// GroupBy is deferred: nothing is grouped until you enumerate it.
var grouped = files.GroupBy(f => Path.GetExtension(f), StringComparer.OrdinalIgnoreCase);

// ToLookup groups right away and keeps the result, like a read-only multi-dictionary.
ILookup<string, string> lookup = files.ToLookup(f => Path.GetExtension(f), StringComparer.OrdinalIgnoreCase);

files.Add("readme.txt"); // added after both calls

Console.WriteLine($"GroupBy  .txt: {string.Join(", ", grouped.First(g => g.Key == ".txt"))}");
Console.WriteLine($"ToLookup .txt: {string.Join(", ", lookup[".txt"])}");

// The comparer merged .jpg and .JPG; the group key is the first one seen.
Console.WriteLine($"keys: {string.Join(" ", grouped.Select(g => g.Key))}");
Console.WriteLine($"lookup[\".JPG\"]: {string.Join(", ", lookup[".JPG"])}");

// A missing key gives an empty sequence, not an exception.
Console.WriteLine($"lookup[\".pdf\"] count: {lookup[".pdf"].Count()}, Contains: {lookup.Contains(".pdf")}");

// A Dictionary built from the groups throws on a missing key instead.
Dictionary<string, List<string>> dict = lookup.ToDictionary(g => g.Key, g => g.ToList(), StringComparer.OrdinalIgnoreCase);
try
{
    Console.WriteLine(dict[".pdf"].Count);
}
catch (KeyNotFoundException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}