Iterate through Expression Tree
Just some thoughts:


Not sure why you don't just flatten the expression tree with a visitor and then return the collection of expressions. This leads to simpler code:


class Program
{
    static void Main(string[] args)
    {
        Expression&lt;Func&lt;int, int, int&gt;&gt; expr = (a, b) =&gt; ((a + b) * (a - b));

        //Flatten the entire tree.
        foreach (var elem in expr.Flatten())
        {
            Console.WriteLine(elem.NodeType);
        }

        //Use Linq to select what you want.
        foreach (var elem in expr.Flatten().Where(t =&gt; t.NodeType == ExpressionType.Parameter))
        {
            Console.WriteLine(elem.NodeType);
        }
        Console.ReadKey();
    }
}

public static class ExpressionExtensions
{
    public static IEnumerable&lt;Expression&gt; Flatten(this Expression expr)
    {
        return Visitor.Flatten(expr);
    }
}

public sealed class Visitor : ExpressionVisitor
{
    private readonly Action&lt;Expression&gt; nodeAction;

    private Visitor(Action&lt;Expression&gt; nodeAction)
    {
        this.nodeAction = nodeAction;
    }

    public override Expression Visit(Expression node)
    {
        nodeAction(node);
        return base.Visit(node);
    }

    public static IEnumerable&lt;Expression&gt; Flatten(Expression expr)
    {
        var ret = new List&lt;Expression&gt;();
        var visitor = new Visitor(t =&gt; ret.Add(t));
        visitor.Visit(expr);
        return ret;
    }
}



Even if, for some reason, you absolutely need to have lazy execution, you're better off making your own expression iterator, rather than trying to pause the execution of a class meant to eagerly visit everything.