> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C# 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>` for in-memory collections, or an `IQueryable>` when querying against an `IQueryable` source. `TKey` represents the type of the grouping key, and `TElement` represents the type of the grouped elements. ```csharp theme={"dark"} using System.Collections.Generic; using System.Linq; public record Product(int CategoryId, string Name); public class GroupExample { public void DemonstrateGrouping() { List sourceSequence = new List { new Product(1, "Apple"), new Product(2, "Banana"), new Product(1, "Cherry") }; // Standard grouping syntax IEnumerable> standardGroup = from product in sourceSequence group product by product.CategoryId; // Grouping with query continuation IEnumerable> 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` Interface** The result of a `group` clause is a sequence of objects implementing `IGrouping`. This interface inherits from `IEnumerable` 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.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` 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`. 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`), `Queryable.GroupBy` (for `IQueryable`), or any custom implementation of the LINQ query pattern. ```csharp theme={"dark"} using System.Collections.Generic; using System.Linq; public record Item(int CategoryId, string Value); public class CompilationExample { public void DemonstrateCompilation() { List source = new List { new Item(1, "A"), new Item(2, "B"), new Item(1, "C") }; // Query Syntax IEnumerable> query = from item in source group item.Value by item.CategoryId; // Compiled Method Syntax Equivalent IEnumerable> 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` 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`):** 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`):** 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` 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.

Tired of Poor C# Skills? Fix That With Deep Grasping! Learn More