> ## 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# Where Clause The `where` clause in C# is a contextual keyword utilized in two distinct language constructs: enforcing compile-time type constraints on generic parameters, and applying boolean predicate filters within Language Integrated Query (LINQ) expressions. ## Generic Type Constraints In generic programming, the `where` clause restricts the types that can be substituted for a type parameter. This allows the compiler to assume specific structural capabilities (such as methods, constructors, or base types) about the type argument, ensuring type safety without requiring boxing or runtime type checking. **Syntax:** ```text theme={"dark"} public class GenericClass where T1 : constraint_list where T2 : constraint_list { // Implementation } ``` **Constraint Categories:** * **Value/Reference Constraints:** * `struct`: The type argument must be a non-nullable value type. * `class`: The type argument must be a reference type. * `class?`: The type argument must be a nullable or non-nullable reference type. * `notnull`: The type argument must be a non-nullable value or reference type. * `unmanaged`: The type argument must be a non-nullable, non-reference type that contains no reference type fields at any level of nesting. * `default`: The type argument is not constrained to `class` or `struct`. This is used when overriding methods or explicitly implementing interfaces to resolve ambiguity when the base method lacks a `class` or `struct` constraint. * **Inheritance Constraints:** * `BaseClassName`: The type argument must be or derive from the specified base class. * `InterfaceName`: The type argument must implement the specified interface. * `U`: The type argument supplied for `T` must be or derive from the argument supplied for `U` (Naked Type Constraint). * **Constructor Constraints:** * `new()`: The type argument must have a public parameterless constructor. * **Anti-Constraints:** * `allows ref struct`: The type argument can be a `ref struct`. This lifts the implicit restriction that generic type parameters cannot be `ref struct` types (introduced in C# 13). **Ordering Rules:** When combining multiple constraints on a single type parameter, the compiler enforces a strict order: 1. **Primary constraint** (`class`, `class?`, `struct`, `unmanaged`, `notnull`, `default`, or a specific base class). 2. **Anti-constraint** (`allows ref struct`). In C# 13, this **cannot** be combined with `class`, `class?`, `unmanaged`, `default`, a specific base class constraint, or the `new()` constructor constraint. Among primary constraints, it can only be combined with `struct` or `notnull`, and must immediately follow the primary constraint. It can also be followed by secondary constraints (like interfaces). 3. **Secondary constraints** (interfaces or naked type constraints). 4. **Constructor constraint** (`new()`), which must always appear last. ```csharp theme={"dark"} // Standard constraint ordering public void Process() where T : class, IDisposable, new() { // Implementation } // Valid constraint ordering with an anti-constraint and secondary constraint public void ProcessSpan() where T : struct, allows ref struct, IDisposable { // Implementation } // Valid constraint ordering combining notnull and allows ref struct public void ProcessNotNull() where T : notnull, allows ref struct { // Implementation } ``` ## LINQ Query Expressions In query syntax, the `where` clause acts as a filtering operator. It evaluates a sequence of elements against a boolean expression (predicate) and yields only the elements that satisfy the condition. **Syntax:** ```text theme={"dark"} var query = from element in collection where boolean_expression select element; ``` **Underlying Mechanics:** During compilation, C# query expressions utilize duck-typing (a purely syntactic translation). The compiler translates the `where` clause into a method invocation named `Where`. It will bind to *any* accessible method (instance or extension) that matches the signature, converting the predicate to whatever delegate or expression type that specific method expects. While this commonly resolves to `Enumerable.Where` (expecting `Func`) or `Queryable.Where` (expecting `Expression>`), it is not strictly limited to those types. ```csharp theme={"dark"} // Query Syntax var queryResult = from item in source where item.Property > 0 select item; // Compiler Translation (Method Syntax) var methodResult = source.Where(item => item.Property > 0); ``` **Execution Characteristics:** * **Deferred Execution:** The `where` clause does not execute immediately. The predicate is evaluated lazily; elements are processed one by one only when the resulting sequence is actively enumerated (e.g., via a `foreach` loop or a terminal operation like `ToList()`). * **Short-Circuiting:** While `where` itself evaluates the predicate for elements as they are yielded, combining it with terminal operators like `First()` or `Any()` will short-circuit the enumeration pipeline once the condition is met. * **Multiple Clauses:** Multiple `where` clauses in a single query expression are translated into chained `.Where()` method calls, which logically act as a boolean `AND` operation.

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