LINQ to Entities 无法识别该方法（在相关实体上）

Question

我正在尝试使一些代码更具可读性，但并没有完全掌握如何构建扩展方法和/或表达式来做到这一点。我们目前有许多实体上都有RecordStatusTypeId（从IRecordStatus 的接口实现）

public interface IRecordStatus
{
    int RecordStatusTypeId { get; set; }
    RecordStatusType RecordStatusType { get; set; }
}

这里的目标是将.Where(RecordStatusTypeId != (int)RecordStatusTypes.Deleted) 之类的语句替换为.ActiveRecords() 之类的扩展方法

我可以使用以下扩展方法来完成此操作：

public static IQueryable<T> ActiveRecords<T>(this DbSet<T> entitySet)
    where T : class, IRecordStatus
{
    return entitySet.Where(e => e.RecordStatusTypeId != (int)RecordStatusTypes.Deleted);
}

*我有DbSet<T>、IQueryable<T>、ICollection<T>和IEnumerable<T>的扩展方法

这对于MyDbContext.Entities.Where(e => e.RecordStatusTypeId != (int)RecordStatusTypes.Deleted) 之类的语句非常有效，但如果我尝试替换以下内容，则会收到错误“LINQ to Entities 无法识别该方法”：

MyDbContext.Entities.Where(e => e.RelatedEntity.Where(re => re.RecordStatusTypeId != (int)RecordStatusTypes.Deleted));

我想做的事：

MyDbContext.Entities.Where(e => e.RelatedEntity.ActiveRecords().Any());

如何更改我的扩展方法（或添加表达式），以便过滤 DbSet 以及 linq 子句内的相关实体上的活动记录？

Answer 1

看来您的转换可能有误。 应该：

MyDbContext.Entities.Where(e => e.RelatedEntity.Where(re => re.RecordStatusTypeId != (int)RecordStatusTypes.Deleted));

转换成这个：

MyDbContext.Entities.Where(e => e.RelatedEntity.ActiveRecords().Any());

Answer 2

您收到异常是因为 Queryable.Where 需要一个可以翻译成 SQL 的表达式，而 ActiveRecords 不能翻译成 SQL。

您需要做的是更新表达式以将对ActiveRecords 的调用扩展为对.Where(e => e.RecordStatusTypeId != (int)RecordStatusTypes.Deleted 的调用。

我将为可行的解决方案提供草稿。它对您提供的示例非常具体。您可能应该努力使其具有通用性。

以下表达式访问者基本上会将对 ActiveRecords 的调用更改为对 Where 的调用，并使用适当的表达式作为参数：

public class MyVisitor : ExpressionVisitor
{
    protected override Expression VisitMethodCall(MethodCallExpression m)
    {
        if (m.Method.Name == "ActiveRecords")
        {
            var entityType = m.Method.GetGenericArguments()[0];
            var whereMethod = genericWhereMethod.MakeGenericMethod(entityType);

            var param = Expression.Parameter(entityType);
            var expressionToPassToWhere =
                Expression.NotEqual(
                    Expression.Property(param, "RecordStatusTypeId"),
                    Expression.Constant((int)RecordStatusTypes.Deleted));

            Expression newExpression =
                Expression.Call(
                    whereMethod,
                    m.Arguments[0],
                    Expression.Lambda(
                        typeof(Func<,>).MakeGenericType(entityType, typeof(bool)),
                        expressionToPassToWhere,
                        param));

            return newExpression;
        }

        return base.VisitMethodCall(m);
    }

    //This is reference to the open version of `Enumerable.Where`
    private static MethodInfo genericWhereMethod;

    static MyVisitor()
    {
        genericWhereMethod = typeof (Enumerable).GetMethods(BindingFlags.Public | BindingFlags.Static)
            .Where(x => x.Name == "Where" && x.GetGenericArguments().Length == 1)
            .Select(x => new {Method = x, Parameters = x.GetParameters()})
            .Where(x => x.Parameters.Length == 2 &&
                        x.Parameters[0].ParameterType.IsGenericType &&
                        x.Parameters[0].ParameterType.GetGenericTypeDefinition() == typeof (IEnumerable<>) &&
                        x.Parameters[1].ParameterType.IsGenericType &&
                        x.Parameters[1].ParameterType.GetGenericTypeDefinition() == typeof (Func<,>))
            .Select(x => x.Method)
            .Single();
    }
}

然后您可以创建一个特殊的WhereSpecial 方法来访问表达式，然后再将其传递给Queryable 的真正Where 方法：

public static class ExtentionMethods
{
    public static IQueryable<T> WhereSpecial<T>(this IQueryable<T> queryable, Expression<Func<T,bool>> expression )
    {
        MyVisitor visitor = new MyVisitor();

        var newBody = visitor.Visit(expression.Body);

        expression = expression.Update(newBody, expression.Parameters);

        return queryable.Where(expression);
    }
}

然后你可以像这样使用它：

var result = MyDbContext.Entities.WhereSpecial(e => e.RelatedEntity.ActiveRecords().Any());

Answer 3

尝试将查询的主要部分设为 IQueryable，然后在 where 子句上添加标签...

类似：

IQueryable temp = from x in MyDbContext.Entities
                  select x;

temp = temp.Where(e => e.RelatedEntity.ActiveRecords().Any());

或评估主要部分，然后执行内存中的位置。