Group Clause

The group clause in C# Language Integrated Query (LINQ) partitions a sequence of elements into a collection of groups based on a specified key selector expression. It terminates a query expression (unless followed by the into contextual keyword). Because LINQ is provider-agnostic, the clause returns an IEnumerable<IGrouping<TKey, TElement>> for in-memory collections, or an IQueryable<IGrouping<TKey, TElement>> when querying against an IQueryable source. TKey represents the type of the grouping key, and TElement represents the type of the grouped elements.

using System.Collections.Generic;
using System.Linq;

public record Product(int CategoryId, string Name);

public class GroupExample
{
    public void DemonstrateGrouping()
    {
        List<Product> sourceSequence = new List<Product>
        {
            new Product(1, "Apple"),
            new Product(2, "Banana"),
            new Product(1, "Cherry")
        };

        // Standard grouping syntax
        IEnumerable<IGrouping<int, Product>> standardGroup = 
            from product in sourceSequence
            group product by product.CategoryId;

        // Grouping with query continuation
        IEnumerable<IGrouping<int, string>> continuedGroup = 
            from product in sourceSequence
            group product.Name by product.CategoryId into groupVariable
            // Subsequent clauses operate on the IGrouping sequence
            select groupVariable;
    }
}

Technical Mechanics

1. The IGrouping<TKey, TElement> Interface The result of a group clause is a sequence of objects implementing IGrouping<TKey, TElement>. This interface inherits from IEnumerable<TElement> and adds a single property: Key. The Key property holds the value evaluated by the by expression, and the enumerable payload contains all elements from the source sequence that produced that specific key.

2. Key Evaluation and Equality During execution, the by expression is evaluated against every element in the source sequence. The runtime groups elements by comparing these keys using the default equality comparer (EqualityComparer<TKey>.Default) for the key’s type. If a custom equality comparer is required, the query expression syntax must be abandoned in favor of the method-based GroupBy extension method, which accepts an IEqualityComparer<TKey> overload.

3. Element Projection The expression immediately following the group keyword dictates the type and shape of the elements stored within the resulting groups (TElement).

• If the range variable itself is specified (group x by x.Id), the group contains the original objects.
• If a projection is specified (group x.Name by x.Id), the group contains only the projected values, altering the TElement type signature of the resulting IGrouping.

4. Query Continuation (into) By default, a group clause ends a LINQ query expression. To perform further operations on the generated groups (such as filtering the groups themselves or sorting them by their keys), the into contextual keyword is required. The into keyword introduces a new range variable that represents the IGrouping<TKey, TElement>. Once into is used, the original range variable representing the source sequence elements falls out of scope and can no longer be referenced.

5. Ordering Semantics The group clause does not automatically sort the resulting groups by their keys. In LINQ to Objects, groups are yielded in the exact order that their keys first appear in the source sequence. Furthermore, the elements within each individual group maintain the same relative order they had in the original source sequence. If sorted groups are required, an explicit orderby clause must be applied to the query continuation after the group...into statement.

6. Method Syntax Compilation At compile time, the C# compiler performs a purely syntactic translation of the group...by query comprehension syntax into a method call named GroupBy. Depending on the source type, this resolves to Enumerable.GroupBy (for IEnumerable<T>), Queryable.GroupBy (for IQueryable<T>), or any custom implementation of the LINQ query pattern.

using System.Collections.Generic;
using System.Linq;

public record Item(int CategoryId, string Value);

public class CompilationExample
{
    public void DemonstrateCompilation()
    {
        List<Item> source = new List<Item>
        {
            new Item(1, "A"),
            new Item(2, "B"),
            new Item(1, "C")
        };

        // Query Syntax
        IEnumerable<IGrouping<int, string>> query = 
            from item in source
            group item.Value by item.CategoryId;

        // Compiled Method Syntax Equivalent
        IEnumerable<IGrouping<int, string>> compiled = source.GroupBy(
            item => item.CategoryId, // keySelector
            item => item.Value       // elementSelector
        );
    }
}

7. Execution Behavior and Memory Allocation The group clause utilizes deferred execution. The grouping operation does not occur until the resulting sequence of IGrouping<TKey, TElement> is iterated over (e.g., via a foreach loop or a call to .ToList()). However, the underlying execution behavior depends entirely on the LINQ provider:

• LINQ to Objects (IEnumerable<T>): Grouping requires reading the entire source sequence to ensure all elements with matching keys are placed in the correct bucket. Upon the first enumeration, the operation is strictly evaluated, consuming the entire source sequence into memory and building a hash-based lookup structure before yielding the first group.
• LINQ to Providers (IQueryable<T>): When executing against a relational database provider (such as Entity Framework Core), the translation depends on whether aggregate functions are applied to the groups. Relational databases do not natively support returning un-aggregated hierarchical data. If the query returns raw IGrouping<TKey, TElement> objects without aggregation, the provider cannot use a SQL GROUP BY. Instead, modern providers (like EF Core 6.0+) translate the query to order the records by the grouping key, stream the flat results from the database, and construct the IGrouping objects in local memory on the client (older versions of EF Core will throw a runtime exception). A native SQL GROUP BY statement is generated only when the query applies an aggregate function (such as Count() or Sum()) to the grouped results.

Master C# with Deep Grasping Methodology!

Learn More