Deferred execution, iterators and IQueryable

Lesson 3 showed that a query does not run until it is enumerated. This lesson looks at how it runs, because that is what interview questions about LINQ are really probing.

yield return: a method that pauses

A method containing yield return is an iterator. Calling it runs none of its body; it returns an object that runs the body only as far as the next yield return each time the consumer asks for an element (MoveNext), then pauses there until asked again.

LINQ operators such as Where, Select and Take are built the same way, so a pipeline streams: one element travels through every stage before the next element is even produced.

1public static class Solution2{3    static IEnumerable<int> Numbers(List<string> log)4    {5        for (int i = 1; i <= 4; i++)6        {7            log.Add("yield " + i);8            yield return i;9        }10    }11 12    public static string Describe()13    {14        var log = new List<string>();15        var query = Numbers(log)16            .Where(n => { log.Add("where " + n); return n % 2 == 0; })17            .Select(n => { log.Add("select " + n); return n * 10; });18        log.Add("query built");19 20        foreach (var x in query.Take(1)) log.Add("got " + x);21        return string.Join(" | ", log);22    }23}

Read the log left to right. Building the query logged nothing. Then 1 was produced and rejected by Where; 2 was produced, passed Where, was projected by Select and handed out; and because Take(1) had what it needed, 3 and 4 were never produced at all. Not every operator streams: OrderBy, GroupBy and Reverse must read the whole input before yielding their first element.

Every enumeration starts again

A query is a recipe, not a result. Enumerate it twice and the whole pipeline runs twice:

1using System.Linq.Expressions;2 3public static class Solution4{5    public static string Describe()6    {7        int evaluations = 0;8        var source = new List<int> { 1, 2, 3, 4 };9        IEnumerable<int> evens = source.Where(n => { evaluations++; return n % 2 == 0; });10        int count = evens.Count();11        var list = evens.ToList();12 13        int limit = 2;14        var above = source.Where(n => n > limit);15        limit = 3;                                // captured variable, read at enumeration time16        string aboveResult = string.Join(",", above);17 18        var bad = source.Select(n => 10 / (n - 3));   // no exception yet19        string failure;20        try { bad.ToList(); failure = "none"; }21        catch (DivideByZeroException) { failure = "DivideByZeroException at ToList"; }22 23        Func<int, bool> compiled = n => n > 2;24        Expression<Func<int, bool>> tree = n => n > 2;25        var queryable = source.AsQueryable().Where(n => n > 2);26 27        return $"evaluations after Count+ToList={evaluations} | above limit={aboveResult} | {failure} | " +28               $"Func={compiled.GetType().Name} Expression body={tree.Body} | IQueryable expression={queryable.Expression}";29    }30}

• Count() and then ToList() ran the Where lambda over four elements each time: 8 evaluations.
• limit was changed after the query was built, and the query used the new value, because the lambda captured the variable (lesson 10).
• The division by zero did not happen where Select was written, but inside ToList(), which is where its stack trace will point.

IEnumerable versus IQueryable

Enumerable.Where takes a Func<T, bool>: compiled code that can only be called. Queryable.Where takes an Expression<Func<T, bool>>: the same lambda written as data, a tree that a provider can inspect and translate. The last two parts of the output above show the difference: the Func is just a delegate type, while the expression tree prints as (n > 2) and an IQueryable carries the whole query as a tree.

That tree is what lets Entity Framework Core turn db.Orders.Where(o => o.Total > 100) into a SQL WHERE clause. Once you call AsEnumerable() or ToList(), the remaining operators run in memory, in C#, on whatever rows came back.