Performance of Compiled C# Lambda Expressions

Consider the following simple manipulation over a collection:

static List<int> x = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var result = x.Where(i => i % 2 == 0).Where(i => i > 5);

Now let's use Expressions. The following code is roughly equivalent:

static void UsingLambda() {
    Func<IEnumerable<int>, IEnumerable<int>> lambda = l => l.Where(i => i % 2 == 0).Where(i => i > 5);
    var t0 = DateTime.Now.Ticks;
    for (int j = 1; j < MAX; j++) 
        var sss = lambda(x).ToList();

    var tn = DateTime.Now.Ticks;
    Console.WriteLine("Using lambda: {0}", tn - t0);
}

But I want to build the expression on-the-fly, so here's a new test:

static void UsingCompiledExpression() {
    var f1 = (Expression<Func<IEnumerable<int>, IEnumerable<int>>>)(l => l.Where(i => i % 2 == 0));
    var f2 = (Expression<Func<IEnumerable<int>, IEnumerable<int>>>)(l => l.Where(i => i > 5));
    var argX = Expression.Parameter(typeof(IEnumerable<int>), "x");
    var f3 = Expression.Invoke(f2, Expression.Invoke(f1, argX));
    var f = Expression.Lambda<Func<IEnumerable<int>, IEnumerable<int>>>(f3, argX);

    var c3 = f.Compile();

    var t0 = DateTime.Now.Ticks;
    for (int j = 1; j < MAX; j++) 
        var sss = c3(x).ToList();

    var tn = DateTime.Now.Ticks;
    Console.WriteLine("Using lambda compiled: {0}", tn - t0);
}

Of course it isn't exactly like the above, so to be fair, I modify the first one slightly:

static void UsingLambdaCombined() {
    Func<IEnumerable<int>, IEnumerable<int>> f1 = l => l.Where(i => i % 2 == 0);
    Func<IEnumerable<int>, IEnumerable<int>> f2 = l => l.Where(i => i > 5);
    Func<IEnumerable<int>, IEnumerable<int>> lambdaCombined = l => f2(f1(l));
    var t0 = DateTime.Now.Ticks;
    for (int j = 1; j < MAX; j++) 
        var sss = lambdaCombined(x).ToList();

    var tn = DateTime.Now.Ticks;
    Console.WriteLine("Using lambda combined: {0}", tn - t0);
}

Now comes the results for MAX = 100000, VS2008, debugging ON:

Using lambda compiled: 23437500
Using lambda:           1250000
Using lambda combined:  1406250

And with debugging OFF:

Using lambda compiled: 21718750
Using lambda:            937500
Using lambda combined:  1093750

Surprise. The compiled expression is roughly 17x slower than the other alternatives. Now here comes the questions:

1. Am I comparing non-equivalent expressions?
2. Is there a mechanism to make .NET "optimize" the compiled expression?
3. How do I express the same chain call l.Where(i => i % 2 == 0).Where(i => i > 5); programatically?

Some more statistics. Visual Studio 2010, debugging ON, optimizations OFF:

Using lambda:           1093974
Using lambda compiled: 15315636
Using lambda combined:   781410

Debugging ON, optimizations ON:

Using lambda:            781305
Using lambda compiled: 15469839
Using lambda combined:   468783

Debugging OFF, optimizations ON:

Using lambda:            625020
Using lambda compiled: 14687970
Using lambda combined:   468765

New Surprise. Switching from VS2008 (C#3) to VS2010 (C#4), makes the UsingLambdaCombined faster than the native lambda.

Ok, I've found a way to improve the lambda compiled performance by more than an order of magnitude. Here's a tip; after running the profiler, 92% of the time is spent on:

System.Reflection.Emit.DynamicMethod.CreateDelegate(class System.Type, object)

Hmmmm... Why is it creating a new delegate in every iteration? I'm not sure, but the solution follows in a separate post.