Does LINQ deferred execution occur when rendering the view, or earlier?

Question

Given a very basic LINQ that is returned to a MVC view, at what exact point does the deferred execution fire?

In the controller:

public ActionResult Index()
{
    var model = _fooService.GetAll();
    return View(model);
}

In the model:

@foreach (var item in Model) {    
    <tr>
        <td>@item.Bar</td>
   </tr>
}

The query is not executed when we call _fooService.GetAll() of course, but is deferred to some later point - but at which exact point is it executed?

• The return View(model); statement in the controller (doesn't look like it)?
• The @foreach (var item in Model) line in the view?
• The first time the @item.Bar line in the view is hit?
• Something else that occurs in between return View(model); and the view being rendered?

Ventriloquize

Answer 1

MSDN documentation addresses this question under the deferred query execution section (emphasis mine).

In a query that returns a sequence of values, the query variable itself never holds the query results and only stores the query commands. Execution of the query is deferred until the query variable is iterated over in a foreach or For Each loop...

That narrows down the answer to options 2 and 3.

foreach is just syntactic sugar, underneath the compiler re-writes that as a while loop. There's a pretty thorough explanation of what happens here. Basically your loop will end up looking something like this

{
  IEnumerator<?> e = ((IEnumerable<?>)Model).GetEnumerator();
  try
  { 
    int m;  // this is inside the loop in C# 5
    while(e.MoveNext())
    {
      m = (?)e.Current;
      // your code goes here
    }
  }
  finally
  { 
    if (e != null) ((IDisposable)e).Dispose();
  }
}

Enumerator is advanced before it reaches your code inside the loop, so slightly before you get to @item.Bar. That only leaves option 2, the @foreach (var item in Model) line (though technically that line doesn't exist after the compiler is done with your code).

I'm not sue if the query will execute on the call to GetEnumerator() or on the first call to e.MoveNext().

---

As @pst points out in the comments, there are other ways to trigger execution of a query, such as by calling ToList, and it may not internally use a foreach loop. MSDN documentation sort of addresses this here:

The IQueryable interface inherits the IEnumerable interface so that if it represents a query, the results of that query can be enumerated. Enumeration causes the expression tree associated with an IQueryable object to be executed. The definition of "executing an expression tree" is specific to a query provider. For example, it may involve translating the expression tree to an appropriate query language for the underlying data source. Queries that do not return enumerable results are executed when the Execute method is called.

My understanding of that is an attempt to enumerate the expression will cause it to execute (be it through a foreach or some other way). How exactly that happens will depend on the implementation of the provider.

Underrate

Answer 2

The query execution (I assume GetAll returns iqueryable) will be deferred into the view, and will be unwrapped on the foreach line, because that is the first place where you start iterating over the collection.

Update For anybody interested, here's "proof". Create a class like this:

public class DiagnosticCollection<T> : System.Collections.Generic.List<T>
{
    public new Enumerator GetEnumerator()
    {
        Debug.Print("Collection Unwrap");
        return base.GetEnumerator();
    }
}

Test it in your view like this:

@model PlayMvc.Models.DiagnosticCollection<string>
@{System.Diagnostics.Debug.Print("Before foreach");}
@foreach (var item in Model)
{
    System.Diagnostics.Debug.Print("After foreach");
    @item
}

Marcusmarcy

I just want to mention that you should probably force execution in the controller. This will prevent problems in the future like accidentally enumerating it multiple times. – Scrapbook

I don't think its such a great idea - what if the view does not need all of the data, eg if its a grid with paging: if you force execution you lose the benefits of that paging – Ventriloquize

This is something to be careful when working with EntityFramework. I first noticed this behavior because objects were getting lazy loaded in the view, which not only I didn't need, but was actually breaking certain business rules. I ended up adding a filter to detach objects from the state manager after controller execution completed to ensure that deferred execution in the view would return null on the lazy loading properties and not issue additional db calls. Something to watch out for... – Marcusmarcy

Answer 3

As a point of clarification, LINQ to SQL/Entity Framework evaluate the LINQ query expressions when the GetEnumerator is called. This is used under the covers by foreach, thus while it appears that deferred execution waits until the foreach happens, it is actually the GetEnumerator that foreach uses that really is the key execution point.

Fivespot

+1 first answer to say at what exact point the execution occurs – Ventriloquize

Answer 4

The work is deferred until it needs to be done. In your example, the query will run when it tries to get a value for item.

Alanaalanah

Your answer is a little misleading because it suggests that writing a loop like this foreach( var item in Model ){ } would not execute the query (since item is ever accessed). – Underrate