为什么要引用 LambdaExpression?
Why would you quote a LambdaExpression?
我读过 this answer 并从中理解了它强调的具体情况,即当你在另一个 lambda 中有一个 lambda 并且你不想不小心让内部 lambda 也与外一个。编译外部表达式时,您希望内部 lambda 表达式保留为表达式树。在那里,是的,引用内部 lambda 表达式是有意义的。
但我相信仅此而已。引用 lambda 表达式还有其他用例吗?
如果没有,为什么所有 LINQ 运算符,即在 Queryable
class 中声明的 IQueryable<T>
上的扩展引用它们收到的谓词或 lambda当他们将该信息打包在 MethodCallExpression
.
中时作为参数
我尝试了一个示例(以及过去几天的其他几个示例),在这种情况下引用 lambda 似乎没有任何意义。
这是一个方法调用表达式,它期望 lambda 表达式(而不是委托实例)作为其唯一参数。
然后我通过将 MethodCallExpression
包装在 lambda 中来编译它。
但这也不会编译内部 LambdaExpression
(GimmeExpression
方法的参数)。它将内部 lambda 表达式保留为表达式树,并且不创建它的委托实例。
事实上,不引用它也能很好地工作。
如果我确实引用了参数,它会中断并给我一个错误,表明我将错误类型的参数传递给 GimmeExpression
方法。
怎么回事?这是什么引述?
private static void TestMethodCallCompilation()
{
var methodInfo = typeof(Program).GetMethod("GimmeExpression",
BindingFlags.NonPublic | BindingFlags.Static);
var lambdaExpression = Expression.Lambda<Func<bool>>(Expression.Constant(true));
var methodCallExpression = Expression.Call(null, methodInfo, lambdaExpression);
var wrapperLambda = Expression.Lambda(methodCallExpression);
wrapperLambda.Compile().DynamicInvoke();
}
private static void GimmeExpression(Expression<Func<bool>> exp)
{
Console.WriteLine(exp.GetType());
Console.WriteLine("Compiling and executing expression...");
Console.WriteLine(exp.Compile().Invoke());
}
您必须将参数作为 ConstantExpression
:
传递
private static void TestMethodCallCompilation()
{
var methodInfo = typeof(Program).GetMethod("GimmeExpression",
BindingFlags.NonPublic | BindingFlags.Static);
var lambdaExpression = Expression.Lambda<Func<bool>>(Expression.Constant(true));
var methodCallExpression =
Expression.Call(null, methodInfo, Expression.Constant(lambdaExpression));
var wrapperLambda = Expression.Lambda(methodCallExpression);
wrapperLambda.Compile().DynamicInvoke();
}
private static void GimmeExpression(Expression<Func<bool>> exp)
{
Console.WriteLine(exp.GetType());
Console.WriteLine("Compiling and executing expression...");
Console.WriteLine(exp.Compile().Invoke());
}
原因应该很明显 - 您正在传递一个常量值,因此它必须是 ConstantExpression
。通过直接传递表达式,您明确地说 "and get the value of exp
from this complicated expression tree"。由于该表达式树实际上 return 不是 Expression<Func<bool>>
的值,因此您会收到错误消息。
IQueryable
的工作方式与此并没有多大关系。 IQueryable
上的扩展方法必须保留有关表达式的所有信息 - 包括 ParameterExpression
的类型和引用等。这是因为它们实际上 不做 任何事情——它们只是构建表达式树。真正的工作发生在您调用 queryable.Provider.Execute(expression)
时。基本上,这就是多态性得以保留的方式,即使我们正在进行组合,而不是继承(/接口实现)。但这确实意味着 IQueryable
扩展方法本身无法执行任何快捷方式 - 它们对 IQueryProvider
实际解释查询的方式一无所知,因此它们无法丢弃任何东西.
不过,您从中获得的最重要的好处是您可以组合查询和子查询。考虑这样的查询:
from item in dataSource
where item.SomeRelatedItem.Where(subItem => subItem.SomeValue == 42).Count() > 2
select item;
现在,这被翻译成这样:
dataSource.Where(item => item.SomeRelatedItem.Where(subItem => subItem.SomeValue == 42).Count() > 2);
外部查询非常明显 - 我们将使用给定的谓词得到一个 Where
。然而,内部查询实际上将是 Call
到 Where
,将实际谓词作为参数。
通过确保 Where
方法的实际调用实际上被转换为 Where
方法的 Call
,这两种情况变得相同,并且您的 LINQProvider 是更简单一点:)
我实际上编写了未实现 IQueryable
的 LINQ 提供程序,并且实际上在 Where
等方法中具有一些有用的逻辑。它更简单、更高效,但具有上述缺点 - 处理子查询的唯一方法是手动 Invoke
Call
表达式来获取 "real" 谓词表达式。哎呀 - 这对于一个简单的 LINQ 查询来说是相当大的开销!
当然,它可以帮助您组合不同的可查询提供程序,尽管我实际上还没有看到 (m) 个在单个查询中使用两个完全不同的提供程序的示例。
至于Expression.Constant
和Expression.Quote
本身的区别,他们似乎很相似。关键区别在于 Expression.Constant
会将任何闭包视为实际的 常量 ,而不是闭包。另一方面,Expression.Quote
将保留闭包的 "closure-ness"。为什么?因为闭包对象本身 也 作为 Expression.Constant
传递 :) 而且由于 IQueryable
树正在做 [...] 的 lambdas 的 lambdas,你真的不想在任何时候丢失闭包语义。
我读过 this answer 并从中理解了它强调的具体情况,即当你在另一个 lambda 中有一个 lambda 并且你不想不小心让内部 lambda 也与外一个。编译外部表达式时,您希望内部 lambda 表达式保留为表达式树。在那里,是的,引用内部 lambda 表达式是有意义的。
但我相信仅此而已。引用 lambda 表达式还有其他用例吗?
如果没有,为什么所有 LINQ 运算符,即在 Queryable
class 中声明的 IQueryable<T>
上的扩展引用它们收到的谓词或 lambda当他们将该信息打包在 MethodCallExpression
.
我尝试了一个示例(以及过去几天的其他几个示例),在这种情况下引用 lambda 似乎没有任何意义。
这是一个方法调用表达式,它期望 lambda 表达式(而不是委托实例)作为其唯一参数。
然后我通过将 MethodCallExpression
包装在 lambda 中来编译它。
但这也不会编译内部 LambdaExpression
(GimmeExpression
方法的参数)。它将内部 lambda 表达式保留为表达式树,并且不创建它的委托实例。
事实上,不引用它也能很好地工作。
如果我确实引用了参数,它会中断并给我一个错误,表明我将错误类型的参数传递给 GimmeExpression
方法。
怎么回事?这是什么引述?
private static void TestMethodCallCompilation()
{
var methodInfo = typeof(Program).GetMethod("GimmeExpression",
BindingFlags.NonPublic | BindingFlags.Static);
var lambdaExpression = Expression.Lambda<Func<bool>>(Expression.Constant(true));
var methodCallExpression = Expression.Call(null, methodInfo, lambdaExpression);
var wrapperLambda = Expression.Lambda(methodCallExpression);
wrapperLambda.Compile().DynamicInvoke();
}
private static void GimmeExpression(Expression<Func<bool>> exp)
{
Console.WriteLine(exp.GetType());
Console.WriteLine("Compiling and executing expression...");
Console.WriteLine(exp.Compile().Invoke());
}
您必须将参数作为 ConstantExpression
:
private static void TestMethodCallCompilation()
{
var methodInfo = typeof(Program).GetMethod("GimmeExpression",
BindingFlags.NonPublic | BindingFlags.Static);
var lambdaExpression = Expression.Lambda<Func<bool>>(Expression.Constant(true));
var methodCallExpression =
Expression.Call(null, methodInfo, Expression.Constant(lambdaExpression));
var wrapperLambda = Expression.Lambda(methodCallExpression);
wrapperLambda.Compile().DynamicInvoke();
}
private static void GimmeExpression(Expression<Func<bool>> exp)
{
Console.WriteLine(exp.GetType());
Console.WriteLine("Compiling and executing expression...");
Console.WriteLine(exp.Compile().Invoke());
}
原因应该很明显 - 您正在传递一个常量值,因此它必须是 ConstantExpression
。通过直接传递表达式,您明确地说 "and get the value of exp
from this complicated expression tree"。由于该表达式树实际上 return 不是 Expression<Func<bool>>
的值,因此您会收到错误消息。
IQueryable
的工作方式与此并没有多大关系。 IQueryable
上的扩展方法必须保留有关表达式的所有信息 - 包括 ParameterExpression
的类型和引用等。这是因为它们实际上 不做 任何事情——它们只是构建表达式树。真正的工作发生在您调用 queryable.Provider.Execute(expression)
时。基本上,这就是多态性得以保留的方式,即使我们正在进行组合,而不是继承(/接口实现)。但这确实意味着 IQueryable
扩展方法本身无法执行任何快捷方式 - 它们对 IQueryProvider
实际解释查询的方式一无所知,因此它们无法丢弃任何东西.
不过,您从中获得的最重要的好处是您可以组合查询和子查询。考虑这样的查询:
from item in dataSource
where item.SomeRelatedItem.Where(subItem => subItem.SomeValue == 42).Count() > 2
select item;
现在,这被翻译成这样:
dataSource.Where(item => item.SomeRelatedItem.Where(subItem => subItem.SomeValue == 42).Count() > 2);
外部查询非常明显 - 我们将使用给定的谓词得到一个 Where
。然而,内部查询实际上将是 Call
到 Where
,将实际谓词作为参数。
通过确保 Where
方法的实际调用实际上被转换为 Where
方法的 Call
,这两种情况变得相同,并且您的 LINQProvider 是更简单一点:)
我实际上编写了未实现 IQueryable
的 LINQ 提供程序,并且实际上在 Where
等方法中具有一些有用的逻辑。它更简单、更高效,但具有上述缺点 - 处理子查询的唯一方法是手动 Invoke
Call
表达式来获取 "real" 谓词表达式。哎呀 - 这对于一个简单的 LINQ 查询来说是相当大的开销!
当然,它可以帮助您组合不同的可查询提供程序,尽管我实际上还没有看到 (m) 个在单个查询中使用两个完全不同的提供程序的示例。
至于Expression.Constant
和Expression.Quote
本身的区别,他们似乎很相似。关键区别在于 Expression.Constant
会将任何闭包视为实际的 常量 ,而不是闭包。另一方面,Expression.Quote
将保留闭包的 "closure-ness"。为什么?因为闭包对象本身 也 作为 Expression.Constant
传递 :) 而且由于 IQueryable
树正在做 [...] 的 lambdas 的 lambdas,你真的不想在任何时候丢失闭包语义。