NotSupportedException 使用已编译的 lambda 表达式进行平均时

Question

我试图回答this question但失败了：

那么让我们以原始查询为例：

var result = db.Employees.GroupBy(x => x.Region)
               .Select(g => new { Region = g.Key, 
                                  Avg = g.Average(x => x.BaseSalary)});

工作正常。现在我们要动态地决定要平均什么。我尝试动态创建 Average 的 lambda：

string property = "BaseSalary";
var parameter = Expression.Parameter(typeof(Employee));
var propAccess = Expression.PropertyOrField(parameter, property);
var expression = (Expression<Func<Employee,int?>>)Expression.Lambda(propAccess, parameter);
var lambda = expression.Compile();

并使用它：

var result = db.Employees.GroupBy(x => x.Region)
               .Select(g => new { Region = g.Key, 
                                  Avg = g.Average(lambda)});

使用 Linq2Sql，这会导致 NotSupportedException:

Für den Abfrageoperator "Average" wurde eine nicht unterstützte Überladung verwendet。

（我只有德语错误信息，上面写着不支持Average 使用的重载，如果您有英文版，请随时编辑）。

原题使用了Linq2Entities，报错

内部 .NET Framework 数据提供程序错误 102

IntelliSense（或其他一些 IDE 功能）告诉我，在两个版本中，编译器都选择了Average 的相同的重载：

double? Enumerable.Average(this IEnumerable<Employee> source, Func<Employee, int?> selector);

我用ExpressionVisitor 重新检查了我的lambda 与x => x.BaseSalary 的表达式完全相同。

那么：为什么突然不再支持它了？

---

有趣：如果我不分组并简单地使用它，则没有这样的例外：

double? result = db.Employees.Average(lambda);

---

对于YuvalShap's answer，我还尝试了Avg = g.AsQueryable().Average(expression)（使用表达式而不是lambda），但结果相同。

Answer 1

您不应该编译 lambda。 EF 使用表达式树而不是编译代码，因此它可以将表达式转换为 SQL，而不是在代码中运行它。

没有编译错误，因为有一个Enumerable.Average，它确实采用了Func<T, int?>，因此使用了重载。但是在转换为 SQL 时，EF 不知道如何处理已编译的 lambda。

由于Average在分组中，你不能将表达式传递给它，你必须将整个表达式构建到Select。

由于可以创建非常模糊的代码，您可以创建一个自定义版本的Select，将表达式的一部分替换为您的自定义表达式以获得平均值，因此至少选择的主要部分是可读的：

public static class Helper
{
    public static IQueryable<TResult> SelectWithReplace<T, TKey, TResult>(this  IQueryable<IGrouping<TKey, T>> queryable, Expression<Func<IGrouping<TKey, T>, Func<T, int?>, TResult>> select, Expression<Func<T, int?>> replaceWith)
    {
        var paramToReplace = select.Parameters[1];
        var newBody = new ReplaceVisitor(paramToReplace, replaceWith).Visit(select.Body);

        var newSelect = Expression.Lambda<Func<IGrouping<TKey, T>, TResult>>(newBody, new[] { select.Parameters.First() });
        return queryable.Select(newSelect);
    }

    public class ReplaceVisitor : ExpressionVisitor
    {
        private readonly ParameterExpression toReplace;
        private readonly Expression replaceWith;

        public ReplaceVisitor(ParameterExpression toReplace, Expression replaceWith)
        {
            this.toReplace = toReplace;
            this.replaceWith = replaceWith;
        }
        protected override Expression VisitParameter(ParameterExpression node)
        {
            if(node == toReplace)
            {
                return this.replaceWith;
            }
            return base.VisitParameter(node);
        }
    }
}

用法：

string property = "BaseSalary";
var parameter = Expression.Parameter(typeof(Employee));
var propAccess = Expression.PropertyOrField(parameter, property);
var expression = (Expression<Func<Employee, int?>>)Expression.Lambda(propAccess, parameter);
var result = db.Employees
    .GroupBy(x => x.Region)
    .SelectWithReplace((g, willReplace) => new
    {
        Region = g.Key,
        Avg = g.Average(willReplace)
    }, expression);