What is the use of decorator sequences in deferred execution?

I won't answer for the actual terminology used, but the guts to understand is that LINQ to Objects is effectively implemented using iterator blocks (whether or not that's the actual implementation is somewhat irrelevant). So for example, ignoring argument validation, consider Where:

public static IEnumerable<T> Where(this IEnumerable<T> source,
                                   Func<T, bool> predicate)
{
    // TODO: Eager argument validation (not as easy as it sounds)
    foreach (var item in source)
    {
        if (predicate(item))
        {
            yield return item;
        }
    }
}

What's important is that this code only asks the original input source for its data when the sequence returned is asked for the next element. That's deferred execution for you. In fact, none of this method executes until the caller asks calls GetEnumerator() and then MoveNext().

This is a decorator in that the returned sequence effectively ends up remembering a reference to the original sequence, and just performing a transformation on it as it goes along, rather than immediately fetching all the items.

For further information on this, see:

• My article on iterator blocks and data pipelines
• My article on iterator block implementation details
• Part 2 of my Edulinq blog series