Internal of Deferred or Lazy Execution in LINQ

I have already posted about Deferred Execution here

In this post we will see how internally Deferred or lazy execution is implemented.

Deferred Execution executes the query only when Loop starts. What I mean here is that, we iterate through the query variable to get the result.

clip_image001

Here the result variable does not contain the actual result. To get the result, we may iterate through the result (query) variable in loop as many time as we want. We do defer execution mainly when multiple values is being returned from the query.

Deferred execution can be avoided

1. By returning single item from the query

2. By converting the query in .ToList().

Lazy evolution of deferred execution is executed using the yield operator in c# 3.0

In c# 3.0 it is implemented as below,

 public static class Sequence
    {
        public static IEnumerable<T> Where<T>(this IEnumerable<T> source,
                                              Func<T, bool> predicate)
        {
            foreach (T element in source)
                if (predicate(element))
                    yield return element;
        }
    }

The main advantage of lazy evolution is if query is returning large result it will cached for better optimization. So here execution is delayed until final query is ready to execute.

About these ads

One thought on “Internal of Deferred or Lazy Execution in LINQ

  1. Pingback: Monthly Report January 2010: Total Posts 19 « debug mode……

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s