New LINQ Methods in .NET 9: Index, CountBy, and AggregateBy

List<Employee> employees =
        [
            new Employee(1, "Jignesh Kumar", "HR"),
            new Employee(2, "Chintan Patel", "IT"),
            new Employee(3, "Emily Johnson", "Marketing"),
            new Employee(3, "Kyle James", "IT"),
            new Employee(3, "Peter Moor", "Marketing"),
            new Employee(3, "Make Patel", "IT"),
        ];

// Apply the CountBy method to the employee list

var departmentCounts = employees.CountBy(emp => emp.Department);

// Loop through and retrieve the count for each department

foreach (var (department, count) in departmentCounts)
{
    Console.WriteLine($"Department: {department}, Employee Count: {count}");
}

Real-Time Debugging Using Visual Studio

Output

Department: HR, Employee Count: 1
Department: IT, Employee Count: 3
Department: Marketing, Employee Count: 2

Before the introduction of the CountBy method in .NET 9.

Using GroupBy and Select

To count elements grouped by a specific key (e.g., department in an employee list), you needed to:

1. Group the elements using GroupBy.
2. Count the elements in each group using Select.

How did developers achieve similar functionality before the CountBy method in .NET 9?

var departmentCounts = employees
    .GroupBy(emp => emp.Department) // Group employees by department
    .Select(group => new 
    { 
        Department = group.Key, 
        Count = group.Count() // Count employees in each group
    })
    .ToList();

// Output the counts
foreach (var item in departmentCounts)
{
    Console.WriteLine($"Department: {item.Department}, Count: {item.Count}");
}

AggregateBy

The AggregateBy method in .NET 9 is a robust LINQ extension designed to streamline aggregate operations such as summing, averaging, or applying custom calculations on grouped data. It offers a more concise and expressive alternative to using a combination of GroupBy with Select or implementing manual aggregation logic.

Syntax

IEnumerable<(TKey Key, TAccumulate Aggregate)> AggregateBy<TSource, TKey, TAccumulate>(
    this IEnumerable<TSource> source,
    Func<TSource, TKey> keySelector,
    Func<TAccumulate> seedFactory,
    Func<TAccumulate, TSource, TAccumulate> aggregator
);

How does AggregateBy Work?

1. Groups the elements based on the key provided by the keySelector.
2. It uses the seed factory to initialize an accumulator for each group.
3. Applies the aggregator function to calculate the aggregate value for each group.

 List<Employee> employees =
             [
                 new Employee(1, "Jignesh Kumar", "HR",50000),
                  new Employee(2, "Chintan Patel", "IT",30000),
                  new Employee(3, "Emily Johnson", "Marketing",20000),
                  new Employee(3, "Kyle James", "IT", 50000),
                  new Employee(3, "Peter Moor", "Marketing", 30000),
                  new Employee(3, "Make Patel", "IT",45000),
             ];

 // Apply the CountBy method to the employee list

 var departmentSalaries = employees.AggregateBy(
             emp => emp.Department,                    // Group by Department
             0m,                                // Seed: Start with 0 salary (initialize as decimal)
             (totalSalary, employee) => totalSalary + employee.Salary  // Aggregate: Sum salaries
         ).ToList();

 // Loop through and retrieve the count for each department
 // Output the results
 foreach (var (department, totalSalary) in departmentSalaries)
 {
     Console.WriteLine($"Department: {department}, Total Salary: {totalSalary:C}");
 }

Real-Time Debugging Using Visual Studio

Output

Department: HR, Total Salary:  50,000.00
Department: IT, Total Salary:  1,25,000.00
Department: Marketing, Total Salary:  50,000.00

Before the introduction of the AggregateBy method in .NET 9.

Using GroupBy and Select

To aggregate data for each group, you would:

1. Use GroupBy to group elements by a specific key.
2. Use Select to project each group into a key-value pair where the value is computed using an aggregate function.

How did developers achieve similar functionality before the AggregateBy method in .NET 9?

var departmentSalaries = employees
    .GroupBy(emp => emp.Department) 
    .Select(group => new 
    { 
        Department = group.Key, 
        TotalSalary = group.Sum(emp => emp.Salary) 
    })
    .ToList();


foreach (var item in departmentSalaries)
{
    Console.WriteLine($"Department: {item.Department}, Total Salary: {item.TotalSalary}");
}

Summary

In this article, I have demonstrated the power and utility of the new LINQ methods introduced in .NET 9 Index, CountBy, and AggregateBy and how they simplify code while improving readability. I provided examples of how developers handled similar tasks before these methods and highlighted the benefits of the new LINQ features in .NET 9.

If you wish to read more articles, please View My Articles

1. Implement a retry policy in .NET 6 Applications with Polly
2. Working with JSON in .NET Core: Newtonsoft.Json, NetJSON, and System.Text.Json
3. Simplify Your Code with Switch Expressions: Patterns and Examples
4. Understanding Model Binding in ASP.NET Core with .NET 8
5. Difference Between =, == And === In JavaScript

Note. I have included my codebase as a zip file, built with Visual Studio 2022 and .NET 9.

Thank you for reading! I hope it was helpful. Please feel free to leave a comment and reach out if you have any questions.