编译的 C# Lambda 表达式性能
本文关键字：表达式 性能 Lambda 编译 | 更新日期: 2023-09-27 17:48:54
考虑对集合进行以下简单操作：
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);
现在让我们使用表达式。以下代码大致等效：
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);
}
但是我想即时构建表达式，所以这里有一个新的测试：
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);
}
当然，它与上述内容并不完全相同，因此为了公平起见，我稍微修改了第一个：
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);
}
现在，MAX = 100000，VS2008，调试打开的结果：
Using lambda compiled: 23437500
Using lambda: 1250000
Using lambda combined: 1406250
在调试关闭的情况下：
Using lambda compiled: 21718750
Using lambda: 937500
Using lambda combined: 1093750
惊喜。编译后的表达式大约比其他替代方法慢 17 倍。现在问题来了：
- 我是否在比较非等效表达式？
- 是否有一种机制可以使 .NET "优化"编译的表达式？
- 如何以编程方式表达相同的链调用
l.Where(i => i % 2 == 0).Where(i => i > 5);？
更多统计数据。Visual Studio 2010，调试打开，优化关闭：
Using lambda: 1093974
Using lambda compiled: 15315636
Using lambda combined: 781410
调试开启，优化开启：
Using lambda: 781305
Using lambda compiled: 15469839
Using lambda combined: 468783
调试关闭，优化打开：
Using lambda: 625020
Using lambda compiled: 14687970
Using lambda combined: 468765
新惊喜。从VS2008（C#3）切换到VS2010（C#4），使UsingLambdaCombined比本机lambda更快。
好的，我找到了一种方法，可以将 lambda 编译的性能提高一个数量级以上。这里有一个提示;运行探查器后，92% 的时间都花在：
System.Reflection.Emit.DynamicMethod.CreateDelegate(class System.Type, object)
嗯......为什么要在每次迭代中创建一个新委托？我不确定，但解决方案在单独的帖子中遵循。
可能是内部 lambda 没有被编译吗?!?下面是一个概念证明：
static void UsingCompiledExpressionWithMethodCall() {
var where = typeof(Enumerable).GetMember("Where").First() as System.Reflection.MethodInfo;
where = where.MakeGenericMethod(typeof(int));
var l = Expression.Parameter(typeof(IEnumerable<int>), "l");
var arg0 = Expression.Parameter(typeof(int), "i");
var lambda0 = Expression.Lambda<Func<int, bool>>(
Expression.Equal(Expression.Modulo(arg0, Expression.Constant(2)),
Expression.Constant(0)), arg0).Compile();
var c1 = Expression.Call(where, l, Expression.Constant(lambda0));
var arg1 = Expression.Parameter(typeof(int), "i");
var lambda1 = Expression.Lambda<Func<int, bool>>(Expression.GreaterThan(arg1, Expression.Constant(5)), arg1).Compile();
var c2 = Expression.Call(where, c1, Expression.Constant(lambda1));
var f = Expression.Lambda<Func<IEnumerable<int>, IEnumerable<int>>>(c2, l);
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 with MethodCall: {0}", tn - t0);
}
现在的时机是：
Using lambda: 625020
Using lambda compiled: 14687970
Using lambda combined: 468765
Using lambda compiled with MethodCall: 468765
呜！它不仅速度快，而且比原生 lambda 更快。（挠头）。
当然，上面的代码写起来太痛苦了。让我们做一些简单的魔法：
static void UsingCompiledConstantExpressions() {
var f1 = (Func<IEnumerable<int>, IEnumerable<int>>)(l => l.Where(i => i % 2 == 0));
var f2 = (Func<IEnumerable<int>, IEnumerable<int>>)(l => l.Where(i => i > 5));
var argX = Expression.Parameter(typeof(IEnumerable<int>), "x");
var f3 = Expression.Invoke(Expression.Constant(f2), Expression.Invoke(Expression.Constant(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 constant: {0}", tn - t0);
}
以及一些时序，VS2010，优化打开，调试关闭：
Using lambda: 781260
Using lambda compiled: 14687970
Using lambda combined: 468756
Using lambda compiled with MethodCall: 468756
Using lambda compiled constant: 468756
现在你可以争辩说，我不是动态生成整个表达式;只是链接调用。但是在上面的例子中，我生成了整个表达式。而且时间匹配。这只是编写更少代码的快捷方式。
据我了解，正在发生的事情是.Compile（） 方法不会将编译传播到内部 lambda，因此不会不断调用 CreateDelegate 。但要真正理解这一点，我很想让一位 .NET 大师对内部发生的事情发表一些评论。
为什么，哦，为什么现在这比本地 lambda 更快！？
最近我问了一个几乎相同的问题：
编译为委托表达式的性能
对我来说，解决方案是我不应该在Expression上调用Compile，而是应该在它上面调用CompileToMethod并将Expression编译为动态程序集中的static方法。
这样：
var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName("MyAssembly_" + Guid.NewGuid().ToString("N")),
AssemblyBuilderAccess.Run);
var moduleBuilder = assemblyBuilder.DefineDynamicModule("Module");
var typeBuilder = moduleBuilder.DefineType("MyType_" + Guid.NewGuid().ToString("N"),
TypeAttributes.Public));
var methodBuilder = typeBuilder.DefineMethod("MyMethod",
MethodAttributes.Public | MethodAttributes.Static);
expression.CompileToMethod(methodBuilder);
var resultingType = typeBuilder.CreateType();
var function = Delegate.CreateDelegate(expression.Type,
resultingType.GetMethod("MyMethod"));
然而，这并不理想。我不太确定这完全适用于哪些类型，但我认为委托作为参数或委托返回的类型必须是public和非泛型的。它必须是非泛型的，因为泛型类型显然可以访问System.__Canon这是 .NET 在泛型类型后台使用的内部类型，这违反了"必须是public类型规则"。
对于这些类型，您可以使用明显较慢的Compile .我通过以下方式检测它们：
private static bool IsPublicType(Type t)
{
if ((!t.IsPublic && !t.IsNestedPublic) || t.IsGenericType)
{
return false;
}
int lastIndex = t.FullName.LastIndexOf('+');
if (lastIndex > 0)
{
var containgTypeName = t.FullName.Substring(0, lastIndex);
var containingType = Type.GetType(containgTypeName + "," + t.Assembly);
if (containingType != null)
{
return containingType.IsPublic;
}
return false;
}
else
{
return t.IsPublic;
}
}
但就像我说的，这并不理想，我仍然想知道为什么将方法编译为动态程序集有时会快一个数量级。我有时这么说是因为我也见过用Compile编译的Expression和普通方法一样快的情况。请参阅我的问题。
或者，如果有人知道使用动态程序集绕过"无非public类型"约束的方法，那也是受欢迎的。
您的表达式不等效，因此您会得到偏斜的结果。 我写了一个测试台来测试这个。 测试包括常规 lambda 调用、等效编译表达式、手工制作的等效编译表达式以及组合版本。 这些应该是更准确的数字。 有趣的是，我没有看到普通版本和组合版本之间的太大差异。 编译的表达式自然会变慢，但只会变慢。 您需要足够大的输入和迭代计数才能获得一些好的数字。 这是有区别的。
至于你的第二个问题，我不知道你如何能够从中获得更多的性能，所以我不能在那里帮助你。 它看起来和它将要得到的一样好。
您将在HandMadeLambdaExpression()方法中找到我对第三个问题的答案。 由于扩展方法，这不是最容易构建的表达式，但可行。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;
using System.Linq.Expressions;
namespace ExpressionBench
{
class Program
{
static void Main(string[] args)
{
var values = Enumerable.Range(0, 5000);
var lambda = GetLambda();
var lambdaExpression = GetLambdaExpression().Compile();
var handMadeLambdaExpression = GetHandMadeLambdaExpression().Compile();
var composed = GetComposed();
var composedExpression = GetComposedExpression().Compile();
var handMadeComposedExpression = GetHandMadeComposedExpression().Compile();
DoTest("Lambda", values, lambda);
DoTest("Lambda Expression", values, lambdaExpression);
DoTest("Hand Made Lambda Expression", values, handMadeLambdaExpression);
Console.WriteLine();
DoTest("Composed", values, composed);
DoTest("Composed Expression", values, composedExpression);
DoTest("Hand Made Composed Expression", values, handMadeComposedExpression);
}
static void DoTest<TInput, TOutput>(string name, TInput sequence, Func<TInput, TOutput> operation, int count = 1000000)
{
for (int _ = 0; _ < 1000; _++)
operation(sequence);
var sw = Stopwatch.StartNew();
for (int _ = 0; _ < count; _++)
operation(sequence);
sw.Stop();
Console.WriteLine("{0}:", name);
Console.WriteLine(" Elapsed: {0,10} {1,10} (ms)", sw.ElapsedTicks, sw.ElapsedMilliseconds);
Console.WriteLine(" Average: {0,10} {1,10} (ms)", decimal.Divide(sw.ElapsedTicks, count), decimal.Divide(sw.ElapsedMilliseconds, count));
}
static Func<IEnumerable<int>, IList<int>> GetLambda()
{
return v => v.Where(i => i % 2 == 0).Where(i => i > 5).ToList();
}
static Expression<Func<IEnumerable<int>, IList<int>>> GetLambdaExpression()
{
return v => v.Where(i => i % 2 == 0).Where(i => i > 5).ToList();
}
static Expression<Func<IEnumerable<int>, IList<int>>> GetHandMadeLambdaExpression()
{
var enumerableMethods = typeof(Enumerable).GetMethods();
var whereMethod = enumerableMethods
.Where(m => m.Name == "Where")
.Select(m => m.MakeGenericMethod(typeof(int)))
.Where(m => m.GetParameters()[1].ParameterType == typeof(Func<int, bool>))
.Single();
var toListMethod = enumerableMethods
.Where(m => m.Name == "ToList")
.Select(m => m.MakeGenericMethod(typeof(int)))
.Single();
// helpers to create the static method call expressions
Func<Expression, ParameterExpression, Func<ParameterExpression, Expression>, Expression> WhereExpression =
(instance, param, body) => Expression.Call(whereMethod, instance, Expression.Lambda(body(param), param));
Func<Expression, Expression> ToListExpression =
instance => Expression.Call(toListMethod, instance);
//return v => v.Where(i => i % 2 == 0).Where(i => i > 5).ToList();
var exprParam = Expression.Parameter(typeof(IEnumerable<int>), "v");
var expr0 = WhereExpression(exprParam,
Expression.Parameter(typeof(int), "i"),
i => Expression.Equal(Expression.Modulo(i, Expression.Constant(2)), Expression.Constant(0)));
var expr1 = WhereExpression(expr0,
Expression.Parameter(typeof(int), "i"),
i => Expression.GreaterThan(i, Expression.Constant(5)));
var exprBody = ToListExpression(expr1);
return Expression.Lambda<Func<IEnumerable<int>, IList<int>>>(exprBody, exprParam);
}
static Func<IEnumerable<int>, IList<int>> GetComposed()
{
Func<IEnumerable<int>, IEnumerable<int>> composed0 =
v => v.Where(i => i % 2 == 0);
Func<IEnumerable<int>, IEnumerable<int>> composed1 =
v => v.Where(i => i > 5);
Func<IEnumerable<int>, IList<int>> composed2 =
v => v.ToList();
return v => composed2(composed1(composed0(v)));
}
static Expression<Func<IEnumerable<int>, IList<int>>> GetComposedExpression()
{
Expression<Func<IEnumerable<int>, IEnumerable<int>>> composed0 =
v => v.Where(i => i % 2 == 0);
Expression<Func<IEnumerable<int>, IEnumerable<int>>> composed1 =
v => v.Where(i => i > 5);
Expression<Func<IEnumerable<int>, IList<int>>> composed2 =
v => v.ToList();
var exprParam = Expression.Parameter(typeof(IEnumerable<int>), "v");
var exprBody = Expression.Invoke(composed2, Expression.Invoke(composed1, Expression.Invoke(composed0, exprParam)));
return Expression.Lambda<Func<IEnumerable<int>, IList<int>>>(exprBody, exprParam);
}
static Expression<Func<IEnumerable<int>, IList<int>>> GetHandMadeComposedExpression()
{
var enumerableMethods = typeof(Enumerable).GetMethods();
var whereMethod = enumerableMethods
.Where(m => m.Name == "Where")
.Select(m => m.MakeGenericMethod(typeof(int)))
.Where(m => m.GetParameters()[1].ParameterType == typeof(Func<int, bool>))
.Single();
var toListMethod = enumerableMethods
.Where(m => m.Name == "ToList")
.Select(m => m.MakeGenericMethod(typeof(int)))
.Single();
Func<ParameterExpression, Func<ParameterExpression, Expression>, Expression> LambdaExpression =
(param, body) => Expression.Lambda(body(param), param);
Func<Expression, ParameterExpression, Func<ParameterExpression, Expression>, Expression> WhereExpression =
(instance, param, body) => Expression.Call(whereMethod, instance, Expression.Lambda(body(param), param));
Func<Expression, Expression> ToListExpression =
instance => Expression.Call(toListMethod, instance);
var composed0 = LambdaExpression(Expression.Parameter(typeof(IEnumerable<int>), "v"),
v => WhereExpression(
v,
Expression.Parameter(typeof(int), "i"),
i => Expression.Equal(Expression.Modulo(i, Expression.Constant(2)), Expression.Constant(0))));
var composed1 = LambdaExpression(Expression.Parameter(typeof(IEnumerable<int>), "v"),
v => WhereExpression(
v,
Expression.Parameter(typeof(int), "i"),
i => Expression.GreaterThan(i, Expression.Constant(5))));
var composed2 = LambdaExpression(Expression.Parameter(typeof(IEnumerable<int>), "v"),
v => ToListExpression(v));
var exprParam = Expression.Parameter(typeof(IEnumerable<int>), "v");
var exprBody = Expression.Invoke(composed2, Expression.Invoke(composed1, Expression.Invoke(composed0, exprParam)));
return Expression.Lambda<Func<IEnumerable<int>, IList<int>>>(exprBody, exprParam);
}
}
}
以及我机器上的结果：
λ： 已通过：340971948 123230（毫秒） 平均： 340.971948 0.12323 （ms）λ表达式： 已用：357077202 129051（毫秒） 平均： 357.077202 0.129051 （ms）手工制作的 lambda 表达式： 已用：345029281 124696（毫秒） 平均： 345.029281 0.124696 （ms）由： 已用：340409238 123027（毫秒） 平均： 340.409238 0.123027 （ms）组合表达式： 已用：350800599 126782（毫秒） 平均值： 350.800599 0.126782 （ms）手工制作组合表达： 已用：352811359 127509（毫秒） 平均： 352.811359 0.127509 （ms）
编译的
lambda 性能相对于委托可能会变慢，因为运行时编译的代码可能不会优化，但是您手动编写的代码和通过 C# 编译器编译的代码会得到优化。
其次，多个 lambda 表达式意味着多个匿名方法，调用每个表达式与计算直接方法相比几乎不需要额外的时间。例如，调用
Console.WriteLine(x);
和
Action x => Console.WriteLine(x);
x(); // this means two different calls..
第二个需要更多的开销，因为从编译器的角度来看，它实际上是两个不同的调用。首先调用 x 本身，然后在该调用 x 的语句中调用。
因此，与单个 lambda 表达式相比，您的组合 Lambda 性能肯定不会降低。
这与内部执行的内容无关，因为您仍在评估正确的逻辑，但您正在添加编译器要执行的其他步骤。
即使在编译表达式树之后，它也不会有优化，它仍然会保留其小的复杂结构，评估和调用它可能会有额外的验证、空检查等，这可能会降低编译的 lambda 表达式的性能。