Standard Query Operators as Extension Methods

Standard query operators are implemented as extension methods that extend the `IEnumerable` interface. This allows methods like `Where` or `Select` to be invoked directly on collections as if they were instance members of the class. To access these methods, the `System.Linq` namespace must be imported into the scope.

The following example demonstrates the semantic equivalence between a query expression (query syntax) and a method-based query (method syntax).

int[] dataSet = [ 5, 10, 8, 3, 6, 12 ];

// Query syntax approach:
IEnumerable<int> resultA =
    from val in dataSet
    where val % 2 == 0
    orderby val
    select val;

// Method syntax approach:
IEnumerable<int> resultB = dataSet
    .Where(val => val % 2 == 0)
    .OrderBy(x => x);

// Execute and display results
Console.WriteLine("Query Syntax Output:");
foreach (int i in resultA) Console.Write($"{i} ");

Console.WriteLine("\nMethod Syntax Output:");
foreach (int i in resultB) Console.Write($"{i} ");

Both implementations produce identical output. The variable type remains `IEnumerable`. In the method syntax example, `Where` is called on the `dataSet` object. Although `IEnumerable` does not inherently define a `Where` method, the extension method mechanism makes it available.

Lambda Expressions in Method Syntax

In method syntax, lambda expressions are often used to pass logic inline to operators. For instance, the condition `val % 2 == 0` is passed as a delegate parameter to the `Where` method: `.Where(val => val % 2 == 0)`. The lambda operator (`=>`) separates the input parameter from the expression body. The compiler infers the type of the input variable based on the collection type. Lambda expressions are a concise way to define delegates and are powerful tools for constructing complex logic within queries.

Composability of Queries

Method syntax supports query chaining, allowing multiple operations to be composed sequentially. For example, `OrderBy` can be chained to `Where`. Because `Where` returns a filtered sequence (an `IEnumerable`), `OrderBy` operates on that result. When using query syntax, the compiler handles this composition behind the scenes. Since query variables store the query definition rather than the result, they can be modified or reused as the basis for new queries even after definition.

Filtering, Sorting, and Grouping

The following examples illustrate filtering, sorting, and grouping using query syntax. The first query filters for values outside a specific range. The second adds ordering. The third groups strings by their first character.

List<int> rawValues = [ 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 ];

// Filter values less than 3 or greater than 7
IEnumerable<int> filteredData =
    from num in rawValues
    where num is < 3 or > 7
    select num;

// Filter and sort ascending
IEnumerable<int> sortedData =
    from num in rawValues
    where num is < 3 or > 7
    orderby num ascending
    select num;

// Group strings by first letter
string[] inventory = ["carrots", "cabbage", "broccoli", "beans", "barley"];
IEnumerable<IGrouping<char, string>> groupedData =
    from item in inventory
    group item by item[0];

Aggregation and Immediate Execution

Operations that return a single value, such as `Sum`, `Max`, `Min`, and `Average`, trigger immediate execution. Unlike deferred operators that return an `IEnumerable`, these aggregation functions cannot be used for further chaining because they return a scalar value.

List<int> setA = [ 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 ];
List<int> setB = [ 15, 14, 11, 13, 19, 18, 16, 17, 12, 10 ];

// Immediate execution: Average
double meanValue = setA.Average();

// Concatenation returns a sequence (deferred)
IEnumerable<int> combinedSet = setA.Concat(setB);

// Filtering with a lambda expression
IEnumerable<int> largeSet = setB.Where(x => x > 15);

Mixing Query and Method Syntax

It is possible to combine query syntax with method syntax. This is often done to perform an aggregation on the results of a query expression. The query expression must be enclosed in parentheses before the dot operator is applied.

// Mixed syntax: Count filtered elements
var countResult = (
    from num in setA
    where num is > 3 and < 7
    select num
).Count();

// Alternative approach using an intermediate variable
IEnumerable<int> intermediateQuery =
    from num in setA
    where num is > 3 and < 7
    select num;

var countResultAlt = intermediateQuery.Count();

Dynamic Predicate Filtering

When filter criteria are unknown at compile time, predicates can be constructed dynamically. A common technique involves using the `Contains` method to filter based on a runtime list of values.

int[] targetIds = [ 111, 114, 112 ];

var dynamicQuery = from student in students
                   where targetIds.Contains(student.ID)
                   select new
                   {
                       student.LastName,
                       student.ID
                   };

// Executing the query with current IDs
foreach (var entry in dynamicQuery)
{
    Console.WriteLine($"{entry.LastName}: {entry.ID}");
}

// Updating IDs changes the query result
targetIds = [ 122, 117, 120, 115 ];

foreach (var entry in dynamicQuery)
{
    Console.WriteLine($"{entry.LastName}: {entry.ID}");
}

Alternatively, standard control flow statements like `switch` or conditional operators can select between pre-defined query structures based on runtime state.

void ExecuteQuery(bool useOddFilter)
{
    IEnumerable<Student> selectedQuery = useOddFilter
        ? (from s in students
           where s.Year is GradeLevel.FirstYear or GradeLevel.ThirdYear
           select s)
        : (from s in students
           where s.Year is GradeLevel.SecondYear or GradeLevel.FourthYear
           select s);
           
    // Process selectedQuery...
}

Handling Null Values

Source collections may contain null elements. If a query does not account for these, a `NullReferenceException` may occur during execution. Defensive coding strategies, such as filtering nulls in a `where` clause, are necessary.

static Category?[] categories =
[
    new ("brass", 1),
    null,
    new ("winds", 2),
    default,
    new ("percussion", 3)
];

static Product?[] products =
[
    new Product("Trumpet", 1),
    new Product("Trombone", 1),
    null,
    new Product("Clarinet", 2),
    new Product("Flute", 2),
    null,
    new Product("Cymbal", 3)
];

// Safe join query filtering nulls
var safeJoin = from cat in categories
               where cat != null
               join prod in products on cat.ID equals prod?.CategoryID
               select new
               {
                   Category = cat.Name,
                   Product = prod.Name
               };

In join operations, if one key is a nullable value type, the other key can be cast to a nullable type to ensure compatibility. Note that while C# supports pattern matching (e.g., `is not null`), some LINQ providers (like Entity Framework Core) may not translate these patterns correctly into native queries. Therefore, standard null checks (`!= null`) are often safer for provider-based queries.

Managing Exceptions in Queries

Methods invoked within a query expression should generally avoid side effects such as modifying the data source or throwing exceptions. To handle exceptions safely, move the logic outside the query expression whenever possible.

If a data source method might throw an exception, wrap the invocation in a `try-catch` block before defining the query.

IEnumerable<int> FetchData() => throw new InvalidOperationException();

IEnumerable<int>? source = null;

try
{
    source = FetchData();
}
catch (InvalidOperationException)
{
    Console.WriteLine("Data retrieval failed.");
}

if (source is not null)
{
    var query = from i in source select i * i;
    foreach (var i in query) Console.WriteLine(i);
}

For exceptions that might occur during the iteration of a query (e.g., within a projection method), wrap the `foreach` loop in a `try-catch` block. The query is executed during enumeration, so this is where runtime exceptions will surface.

string ProcessFile(string path) =>
    path[4] == 'C' ?
        throw new InvalidOperationException() :
        $"C:\\processed\\{path}";

string[] fileNames = ["fileA.txt", "fileB.txt", "fileC.txt"];

var fileQuery = from file in fileNames
                 let result = ProcessFile(file)
                 select result;

try
{
    foreach (var item in fileQuery)
    {
        Console.WriteLine($"Processing {item}");
    }
}
catch (InvalidOperationException e)
{
    Console.WriteLine($"Error: {e.Message}");
}

Catching specific exceptions expected during execution is acceptable, provided the reasoning is well-understood. Always ensure necessary cleanup is performed in a `finally` block if required.