当编译一个LambdaExpression嵌套LambdaExpressions，将他们也编？

Question

当在运行时建立LambdaExpression，如果我用一个LambdaExpression作为参数来调用表达式（使用LINQ时等），然后编译主拉姆达，确实嵌套拉姆达也编译或是否需要？

代码功能相同，如果我使用LambdaExpression作为参数的方法服用Func<T, T2>或者如果我编译并使用Expression.Constant在编译Func。

不编译：

    var selectParam = Expression.Parameter(propType, "selectParam");
    var selectExp = Expression.Call(typeof(System.Linq.Enumerable).GetMethods().First(a => a.Name == "Select" && /*Func<TSource,TResult>*/ a.GetParameters().Last().ParameterType.GenericTypeArguments.Length == 2).MakeGenericMethod(propType, typeof(int)),
                                    whereExp,
                                    Expression.Lambda(Expression.Property(selectParam, "Length"), selectParam));

编译：

    var selectParam = Expression.Parameter(propType, "selectParam");
    var selectExp = Expression.Call(typeof(System.Linq.Enumerable).GetMethods().First(a => a.Name == "Select" && /*Func<TSource,TResult>*/ a.GetParameters().Last().ParameterType.GenericTypeArguments.Length == 2).MakeGenericMethod(propType, typeof(int)),
                                    whereExp,
                                    Expression.Constant(Expression.Lambda(Expression.Property(selectParam, "Length"), selectParam).Compile())); //compile

我建立的表达式称为数百万次的循环，所以我想知道，如果编制外的λ正确编译内lambda表达式。

由于这是不容易解释，看看我的小提琴here。

我敢肯定，他们不会被编译成被称为能想到它们作为表达式解析它们的方法。在这种情况下，有一个运行时的性能增益这样使用时，编译它们？

在更高层次上思考，当在一个循环的标准方式使用 - 这是在所有优化？当然，在一个阵列或者这样做LINQ的时候都不会编上每一个电话？

Answer 1

简短的回答：是的，每个内部拉姆达将被编译。

---

我稍微修改您的第一种方法（但它会产生相同的表达）：

private static Expression<Func<int>> ActuallyInnerAlsoCompile()
{
    var strType = typeof(string);
    var intType = typeof(int);
    var enumearbleType = typeof(Enumerable);

    var array = Expression.NewArrayInit(strType, Expression.Constant("test"), Expression.Constant("test2"));

    var x = Expression.Parameter(strType, "whereParam");
    var whereExp = Expression.Call(enumearbleType,
        "Where",
        new[] {strType},
        array,
        Expression.Lambda(Expression.NotEqual(Expression.PropertyOrField(x, "Length"), Expression.Constant(4)), x));

    var selectExp = Expression.Call(enumearbleType,
        "Select",
        new[] {strType, intType},
        whereExp,
        Expression.Lambda(Expression.PropertyOrField(x, "Length"), x));

    var firstOrDefault = Expression.Call(enumearbleType,
        "FirstOrDefault",
        new[] {intType},
        selectExp);

    return Expression.Lambda<Func<int>>(firstOrDefault);
}

现在，你可以参考这个answer和编译表达到新的装配：

var lambda = ActuallyInnerAlsoCompile();

var dynamicAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
    new AssemblyName("dynamicAssembly"),
    AssemblyBuilderAccess.Save);

var dm = dynamicAssembly.DefineDynamicModule("dynamicModule", "dynamic.dll");
var dt = dm.DefineType("dynamicType");
var m1 = dt.DefineMethod(
    "dynamicMethod",
    MethodAttributes.Public | MethodAttributes.Static);

lambda.CompileToMethod(m1);
dt.CreateType();

dynamicAssembly.Save("dynamic.dll");

如果打开dynamic.dll一些IL工具（dotPeek为例），你会看到类似这样的：

// Decompiled with JetBrains decompiler
// Type: dynamicType
// Assembly: dynamicAssembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: 94346EDD-3BCD-4EB8-BA4E-C25343918535

using System;
using System.Collections.Generic;
using System.Linq;

internal class dynamicType
{
  public static int dynamicMethod()
  {
    return ((IEnumerable<string>) new string[2]
    {
      "test",
      "test2"
    }).Where<string>(new Func<string, bool>(dynamicType.\u003CExpressionCompilerImplementationDetails\u003E\u007B1\u007Dlambda_method)).Select<string, int>(new Func<string, int>(dynamicType.\u003CExpressionCompilerImplementationDetails\u003E\u007B2\u007Dlambda_method)).FirstOrDefault<int>();
  }

  private static bool \u003CExpressionCompilerImplementationDetails\u003E\u007B1\u007Dlambda_method(string whereParam)
  {
    return whereParam.Length != 4;
  }

  private static int \u003CExpressionCompilerImplementationDetails\u003E\u007B2\u007Dlambda_method(string whereParam)
  {
    return whereParam.Length;
  }
}

或（不难看Unicode转义序列）