Question

I’m interested in the compilation and optimization LINQ expressions and whether or not I need to carefull consider the order of let and where clauses in my expression.

Here is example:

var query = 
    from record in Database.Table
    let recordName = record.GetName()
    let notUsed = UselessData()
    let stuff = DoSomethingIntensiveWith(record)
    where recordName == "foobar"
    select stuff;

foreach (string item in query) {
    Console.WriteLine("item => '{0}'", item);
}

Questions/assumptions:

• record.GetName() must be resolved in order to execute the where
  clause.
• notUsed is never used in the expression, so will UselessData() get called
  at all?
• stuff is only needed if recordName equals “foobar”. Will
  DoSomethingIntensiveWith() be executed for every record or just records
  where recordName equals “foobar”?

If I want to ensure DoSomethingIntensiveWith() is only called when
recordName equals “foobar”, do I need to position the let caluse after the
where clause, as follows:

var query = 
    from record in Database.Table
    let recordName = record.GetName()
    let notUsed = UselessData()
    where recordName == "foobar"
    let stuff = DoSomethingIntensiveWith(record)
    select stuff;

foreach (string item in query) {
    Console.WriteLine("item => '{0}'", item);
}

In the meantime, I’m going to play with some real code and the debugger. I’ll
report back what I find.

Answer 1

If this is LINQ-to-Objects, then: yes, you do. The standard Enumerable.* implementation is very direct in terms of applying things in order. You don’t need all the let clauses necessarily, but things are still done in order, and that order is respected. If it is LINQ-to-anything-else, then all bets are off.

This is easy to demonstrate:

using System;
using System.Linq;
class Foo
{
    public Foo(string value)
    {
        Value = value;
    }
    public string Value { get; private set; }
    public string Expensive()
    {
        Console.WriteLine(Value);
        return Value;
    }
    static void Main()
    {
        var foos = new[] {
            new Foo("abc"),
            new Foo("def")};
        Console.WriteLine("query1:");
        var query1 = (from obj in foos
                      let val = obj.Value
                      where val.StartsWith("a")
                      let result = obj.Expensive()
                      select result).ToArray();
        Console.WriteLine("query2:");
        var query2 = (from obj in foos
                      let val = obj.Value
                      let result = obj.Expensive()
                      where val.StartsWith("a")                      
                      select result).ToArray();    
    }
}

The first query filters then projects (so it only does the expensive operation for the matching records), while the second query calculates the expensive operation for both:

query1:
abc
query2:
abc
def

It should be noted that let is actually just implemented via Select – it is a projection from the source data to an anonymous type used internally to the query.