.NET 9 Preview — New LINQ Methods

While the release of .NET 9 is planned for November 2024, the preview version is already available. One of the new .NET 9 features is the new LINQ methods: CountBy, AggregateBy and Index. In this article, I present how to use these methods.

For demonstration purposes, I created a console application using .NET version 9.0.100-preview.2.24157.14. The complete code can be found on my GitHub.

Note that as these methods are still in a Preview version, it might happen some changes until the official release.

The CountBy Method

The CountBy method allows you to group items and returns an IEnumerable of Key-Value Pairs.

For example, in the code below there is a method that has a string (sourceText), and there is a LINQ query that does the following:

• Split: it splits the string into an array of words using space, period and comma as delimiters.
• Select: it converts each word to lowercase
• CountyBy: this is the new LINQ method, which groups the item (in this example, a word) in a key-value pair.
• MaxBy: it finds the most frequent word in the string.

public static class CountyByDemo
{
   public static void Execute()
   {
       string sourceText = """
           Lorem ipsum dolor sit amet, consectetur adipiscing elit.
           Sed non risus. Suspendisse lectus tortor, dignissim sit amet, 
           adipiscing nec, ultricies sed, dolor. Cras elementum ultrices amet diam.
       """;

       KeyValuePair<string, int> mostFrequentWord = sourceText
           .Split(new char[] { ' ', '.', ',' }, StringSplitOptions.RemoveEmptyEntries)
           .Select(word => word.ToLowerInvariant())
           .CountBy(word => word)
           .MaxBy(pair => pair.Value);

       Console.WriteLine(mostFrequentWord.Key);
   }
}

The output is:

amet

The AggregateBy Method

The AggregateBy method allows you to group items and calculate values that are associated with a given key.

For demonstration purposes, I created the ScoreEntry class that will be used in the next example. This class has a PlayerId property of type string and a Score property of type int:

private class ScoreEntry
{
   public string PlayerId { get; init; }
   public int Score { get; init; }

   public ScoreEntry(string playerId, int score)
   {
       PlayerId = playerId;
       Score = score;
   }
}

In the code below we group the items (in this example, the ScoreEntry items), and it sums the value Score associated with a given key (PlayerId):

public static class AggregateByDemo
{
    public static void Execute()
    {
        var scoreEntries = new List<ScoreEntry>
        {
            new ("1", 50),
            new ("2", 20),
            new ("1", 40),
            new ("3", 10),
            new ("2", 30)
        };

         var aggregatedData = scoreEntries
             .AggregateBy(
                 keySelector: entry => entry.PlayerId,
                 seed: 0,
                 (totalScore, curr) => totalScore + curr.Score
             );
  
        foreach (var item in aggregatedData)
            Console.WriteLine(item);
    }
}

The AggregateBy method receives three parameters:

• The first parameter is the item we want to group, which in this case is the PlayerId.
• The second parameter is the seed, which means the increment we want to apply. In this case, it is zero, if we add 1, it will sum the value 1 in the total.
• The third parameter is the tuple, which sums the score for each element.

The output is:

[1, 90]
[2, 50]
[3, 10]

The Index Method

The Index method allows you to extract the index of an Enumerable.

For demonstration purposes, I created a User class, which contains a Name property of type string, that is going to be used for this example:

private class User
{
   public string Name { get; init; }

   public User(string name)
   {
       Name = name;
   }
}

Using the Index method, we can return the index and the related value for each item, for example:

public static class IndexDemo
{
   public static void Execute()
   {
       var users = new List<User>
       {
           new ("Ana"),
           new ("Camille"),
           new ("Bob"),
           new ("Jasmine")
       };

       foreach (var (index, user) in users.Index())
           Console.WriteLine($"Index {index} - {user.Name}");
   }
}

The Index method returns a sequence of tuples where each tuple contains an index and the corresponding value from the users collection. The tuple is deconstructed into two variables: index and user. This allows simultaneous access to both the index and the user object for each item in the collection.

The output is:

Index 0 - Ana
Index 1 - Camille
Index 2 - Bob
Index 3 - Jasmine

In the previous .NET version, we could do the same thing but with Select:

foreach (var (user, index) in users.Select((user, index) => (user, index)))
    Console.WriteLine($"Index {index} - {user.Name}");

But now with the Index method, it’s simpler and easier to achieve the same result.

Conclusion

These new LINQ methods are coming in .NET 9, and provide an easy way to group items and return index positions of items in a list. Note that this is still in a preview version, so there might be some changes until the official release date in November 2024.

This is the link for the project in GitHub: https://github.com/henriquesd/DotNet9NewLinqMethods

If you like this demo, I kindly ask you to give a ⭐️ in the repository.

Thanks for reading!

References

What’s new in .NET 9 — Microsoft Docs