Grouping

GroupBy takes a lambda that produces a key for each item, and returns one group per distinct key. A group is two things at once: it carries the key, and it is itself a sequence of the items that share that key.

That second half is the part worth holding on to. Because a group is a sequence, every operator you already know works on it. Counting a group, averaging a group, ordering inside a group — none of these need anything new.

IEnumerable<IGrouping<string, Employee>> byDepartment = employees
    .GroupBy(e => e.Department);

foreach (IGrouping<string, Employee> group in byDepartment)
{
    Console.WriteLine(
        $"{group.Key}: headcount {group.Count()}, average {group.Average(e => e.AnnualSalary)}");
}
// Engineering: headcount 3, average 1800000
// Support: headcount 2, average 840000
// Sales: headcount 2, average 1900000
// Finance: headcount 1, average 950000

• IGrouping<string, Employee> reads as "a group of Employee items identified by a string key". The two type arguments are the key type and the item type, in that order.
• group.Key is the department name. Everything else about the group is reached by treating it as a sequence: Count() counts its items, Average(e => e.AnnualSalary) averages a value across them.
• The groups arrive in the order each key was first seen in the source, not in alphabetical order. Engineering comes first because Asha Mehta is the first employee in the list. Add OrderBy(g => g.Key) when you want alphabetical.
• Inside the groups, items keep their original relative order. Nothing is sorted unless you sort it.
• The eight employees are still eight employees. Grouping rearranges the view; it does not filter anything out.

var summary = employees
    .GroupBy(e => e.Department)
    .Select(g => new
    {
        Department = g.Key,
        Headcount = g.Count(),
        TotalSalary = g.Sum(e => e.AnnualSalary),
        TopEarner = g.OrderByDescending(e => e.AnnualSalary).First().Name,
    })
    .OrderByDescending(row => row.TotalSalary);

foreach (var row in summary)
{
    Console.WriteLine(
        $"{row.Department}: {row.Headcount} people, {row.TotalSalary} total, top earner {row.TopEarner}");
}
// Engineering: 3 people, 5400000 total, top earner Neha Kulkarni
// Sales: 2 people, 3800000 total, top earner Meera Nair
// Support: 2 people, 1680000 total, top earner Divya Rao
// Finance: 1 people, 950000 total, top earner Sanjay Gupta

• This is the shape most reports want: one row per group, with the details already reduced to numbers. GroupBy gathers, Select summarises.
• Inside the Select, g is a group, so g.OrderByDescending(...).First() finds the highest paid member of that group. First is safe here — a group cannot be empty, because a group only exists when something is in it.
• OrderByDescending at the end sorts the summary rows, not the employees. By that point the sequence is rows, and the operators apply to whatever the current element type is.
• The anonymous type is fine here because everything happens in one method. To return this from a method, declare a record — the projection lesson covers why.
• Only the last output line is grammatically awkward: "1 people". Fixing that is a formatting concern, not a query concern, and it belongs in the code that prints rather than in the query that produces them.