How does LINQ to Objects work under the hood? Explain how operators like Where and Select are implemented as extension methods and iterators, query syntax versus method syntax, streaming versus buffering operators, and the newer operators added in .NET 6 to .NET 10.

1. The pull model

LINQ to Objects is pull-based: the consumer calls MoveNext() on the outermost enumerator, which calls MoveNext() on the next inner one, down to the source. Each item travels through the entire pipeline before the next is requested. Consequences:

• Short-circuiting operators (First, Any, Take) stop pulling early — the rest of the source is never read.
• Side effects in lambdas run during enumeration, interleaved across operators, not operator by operator.
• Enumerating twice runs the whole pipeline twice.

2. BCL optimisations

The .NET team has heavily optimised LINQ, especially in .NET 7–10:

• Iterator fusion: Where(...).Select(...) on a List<T> produces a single ListWhereSelectIterator.
• Type-specific fast paths: Count() on ICollection<T> uses .Count; ToArray() on known-size sources allocates exactly once; Sum, Min, Max, Average on int[]/List<int> use SIMD (Vector<T>).
• IPartition<T>/IIListProvider<T> internal interfaces let Skip/Take/First/Last/ElementAt avoid enumerating.
• Span-based paths: many operators detect arrays/lists and work on spans internally.
• .NET 9/10 reduced iterator allocations and improved OrderBy(...).First()-style patterns.

So modern LINQ is often close to hand-written loops for simple pipelines, though still not free (delegate calls, iterator objects).

3. Query syntax translation

from o in orders where o.Total > 100 select o.Id
  → orders.Where(o => o.Total > 100).Select(o => o.Id)

from c in customers from o in c.Orders select new { c.Name, o.Id }
  → customers.SelectMany(c => c.Orders, (c, o) => new { c.Name, o.Id })

from o in orders let gst = o.Total * 0.1m where gst > 10 select gst
  → orders.Select(o => new { o, gst = o.Total * 0.1m }).Where(t => t.gst > 10).Select(t => t.gst)

let introduces transparent identifiers (anonymous types), adding allocations.

4. Complexity cheat sheet

5. LINQ and async

IEnumerable<T> LINQ is synchronous. For IAsyncEnumerable<T>, .NET 10 includes System.Linq.AsyncEnumerable operators (WhereAwait-style APIs previously came from the System.Linq.Async package). EF Core provides its own async terminal operators (ToListAsync, FirstOrDefaultAsync).

Try it yourself

1. Add Console.WriteLine inside Where and Select lambdas and observe the interleaving during enumeration.
2. Compare OrderBy(x => x).First() with Min() / MinBy on 10 million items for time and memory.
3. Rewrite a query-syntax join in method syntax and compare readability.
4. Try Chunk, CountBy, Index and (on .NET 10) LeftJoin.

namespace Linq.Objects;

public sealed record Transaction(int Id, string AccountId, decimal Amount, DateOnly Date);

public static class Program
{
    public static void Main()
    {
        List<Transaction> txns =
        [
            new(1, "A", 120m, new(2026, 10, 1)),
            new(2, "B", -40m, new(2026, 10, 2)),
            new(3, "A", 75m, new(2026, 10, 3)),
            new(4, "C", 300m, new(2026, 10, 3)),
        ];

        // Method syntax: lazy pipeline
        var large = txns.Where(t => t.Amount > 100m).Select(t => t.Id);

        // Query syntax compiles to the same calls
        var byDate = from t in txns
                     where t.Amount > 0
                     orderby t.Date descending
                     select new { t.Id, t.Date };

        Console.WriteLine(string.Join(",", large));
        Console.WriteLine(string.Join(",", byDate.Select(x => x.Id)));

        // .NET 6+: Chunk, MaxBy, DistinctBy
        foreach (var batch in txns.Chunk(2)) Console.WriteLine($"batch of {batch.Length}");
        Console.WriteLine(txns.MaxBy(t => t.Amount)?.Id);

        // .NET 9: CountBy, AggregateBy, Index
        foreach (var (account, count) in txns.CountBy(t => t.AccountId)) Console.WriteLine($"{account}: {count}");
        foreach (var (account, total) in txns.AggregateBy(t => t.AccountId, 0m, (sum, t) => sum + t.Amount))
            Console.WriteLine($"{account} total {total}");
        foreach (var (index, t) in txns.Index()) Console.WriteLine($"#{index} -> {t.Id}");

        // .NET 10: LeftJoin
        Dictionary<string, string> names = new() { ["A"] = "Alice", ["B"] = "Bob" };
        var joined = txns.LeftJoin(names, t => t.AccountId, n => n.Key,
            (t, n) => $"{t.Id}: {(n.Key is null ? "unknown" : n.Value)}");
        Console.WriteLine(string.Join(" | ", joined));
    }
}