重用排序逻辑

Question

我有一个描述 post:

的特定排序顺序的枚举

enum PostOrder
{
    TitleAsc,
    TitleDesc,
    ScoreAsc,
    ScoreDesc,
}

和重用排序逻辑的扩展方法：

static class IQueryableExtensions
{
    public static IOrderedQueryable<Post> OrderByCommon(this IQueryable<Post> queryable, PostOrder orderBy)
        => orderBy switch
        {
            PostOrder.TitleAsc => queryable.OrderBy(x => x.Title),
            PostOrder.TitleDesc => queryable.OrderByDescending(x => x.Title),
            PostOrder.ScoreAsc => queryable.OrderBy(x => x.Score).ThenBy(x => x.Title),
            PostOrder.ScoreDesc => queryable.OrderByDescending(x => x.Score).ThenBy(x => x.Title),
            _ => throw new NotSupportedException(),
        };
}

扩展方法在正常上下文中使用时有效，但在此处失败：

var input = PostOrder.ScoreDesc;
var dbContext = new QuestionContext();
var users = dbContext.Users
    .Select(x => new
    {
        User = x,
        Top3Posts = x.Posts.AsQueryable()
            .OrderByCommon(input)
            .Take(3)
            .ToList()
    }).ToList();

出现此错误：

The LINQ expression 'MaterializeCollectionNavigation(
    Navigation: User.Posts,
    subquery: NavigationExpansionExpression
        Source: DbSet<Post>()
            .Where(p => EF.Property<Nullable<int>>(u, "Id") != null && object.Equals(
                objA: (object)EF.Property<Nullable<int>>(u, "Id"), 
                objB: (object)EF.Property<Nullable<int>>(p, "AuthorId")))
        PendingSelector: p => NavigationTreeExpression
            Value: EntityReference: Post
            Expression: p
        .Where(i => EF.Property<Nullable<int>>(NavigationTreeExpression
            Value: EntityReference: User
            Expression: u, "Id") != null && object.Equals(
            objA: (object)EF.Property<Nullable<int>>(NavigationTreeExpression
                Value: EntityReference: User
                Expression: u, "Id"), 
            objB: (object)EF.Property<Nullable<int>>(i, "AuthorId")))
    .AsQueryable()
    .OrderByCommon(__input_0)
    .Take(3)' could not be translated. Either rewrite the query in a form that can be translated, or switch to client evaluation explicitly by inserting a call to either AsEnumerable(), AsAsyncEnumerable(), ToList(), or ToListAsync(). See https://go.microsoft.com/fwlink/?linkid=2101038 for more information.

可能是因为它在 Expression<> 上下文中使用。

我怎样才能让它在那里工作？

可以找到一个可复制的项目in this repository。

Answer 1

这是一个众所周知的问题，没有通用的解决方案。

表达式树翻译的一般问题是它纯粹基于知识 - 实际上没有调用任何方法，已知方法由签名标识并根据其已知语义进行翻译。这就是自定义 methods/properties/delegates 无法翻译的原因。

这个问题通常通过使用一些表达式操作库来解决。在我使用 EF6/EF Core 的过程中，我尝试了很多 - LinqKit、NeinLinq、AutoMapper，最近尝试了 DelegateDecompiler。它们都允许用相应的原始表达式替换（扩展）表达式树的部分，就像您手动编写它们一样。

这种特殊情况下的问题更为复杂，因为要进行翻译，必须实际调用自定义方法。但是怎么办？特别是， IQueryble 参数是什么？注意这里

x.Posts.AsQueryable()

您没有 x 实例，因此没有 Posts 集合实例可以调用 AsQueryable() 并将其传递给自定义方法。

一种可能的解决方案是调用将假 LINQ 传递给对象的方法 IQueryable，然后在生成的查询表达式树中查找并用实际表达式替换它。

下面是上述思路的实现：

partial class IQueryableExtensions
{ 
    public static IQueryable<T> Transform<T>(this IQueryable<T> source)
    {
        var expression = new QueryableMethodTransformer().Visit(source.Expression);
        return expression == source.Expression ? source : source.Provider.CreateQuery<T>(expression);
    }

    class QueryableMethodTransformer : ExpressionVisitor
    {
        protected override Expression VisitMethodCall(MethodCallExpression node)
        {
            if (node.Method.DeclaringType == typeof(IQueryableExtensions) &&
                node.Method.IsStatic &&
                typeof(IQueryable).IsAssignableFrom(node.Method.ReturnType) &&
                node.Arguments.Count > 1 &&
                node.Arguments[0].Type.IsGenericType &&
                node.Arguments[0].Type.GetGenericTypeDefinition() == typeof(IQueryable<>))
            {
                // Extract arguments
                var args = new object[node.Arguments.Count];
                int index = 1;
                while (index < args.Length && TryExtractValue(Visit(node.Arguments[index]), out args[index]))
                    index++;
                if (index == args.Length)
                {
                    var source = node.Arguments[0];
                    var elementType = source.Type.GetGenericArguments()[0];
                    // Create fake queryable instance
                    var fakeSource = args[0] = EmptyQueryableMethod
                        .MakeGenericMethod(elementType)
                        .Invoke(null, null);
                    // Invoke the method with it
                    var result = (IQueryable)node.Method.Invoke(null, args);
                    // Replace it with the actual queryable expression
                    return new ConstValueReplacer
                    {
                        From = fakeSource,
                        To = source
                    }.Visit(result.Expression);
                }
            }
            return base.VisitMethodCall(node);
        }

        static IQueryable<T> EmptyQueryable<T>() => Enumerable.Empty<T>().AsQueryable();

        static readonly MethodInfo EmptyQueryableMethod = typeof(QueryableMethodTransformer)
            .GetMethod(nameof(EmptyQueryable), BindingFlags.NonPublic | BindingFlags.Static);

        static bool TryExtractValue(Expression source, out object value)
        {
            if (source is ConstantExpression constExpr)
            {
                value = constExpr.Value;
                return true;
            }
            if (source is MemberExpression memberExpr && TryExtractValue(memberExpr.Expression, out var instance))
            {
                value = memberExpr.Member is FieldInfo field ? field.GetValue(instance) :
                    ((PropertyInfo)memberExpr.Member).GetValue(instance);
                return true;
            }
            value = null;
            return source == null;
        }
    }

    class ConstValueReplacer : ExpressionVisitor
    {
        public object From;
        public Expression To;
        protected override Expression VisitConstant(ConstantExpression node) =>
            node.Value == From ? To : base.VisitConstant(node);
    }
}

正如你所看到的，它不是很通用，因为它有很多假设 - 发现一个静态方法采用第一个 IQueryable<T> 参数和其他可评估的参数（常数值或 field/properties常数值，这是闭包的情况）并执行上述操作。

但它解决了特定问题。您只需要在查询结束时（实现之前）调用 Transform：

var users = dbContext.Users
    .Select(x => new
    {
        User = x,
        Top3Posts = x.Posts.AsQueryable()
            .OrderByCommon(input)
            .Take(3)
            .ToList()
    })
    .Transform() // <--
    .ToList();

现在，可以通过将 QueryableMethodTransformer 插入 EF Core 查询翻译管道来避免 Transform 调用的需要，但仅调用一个方法就需要大量管道代码。请注意，它必须插入到查询预翻译器中，因为 IMethodCallTranslator 无法处理 IQueryable（通常是 IEnumerable）参数。如果您有兴趣，我对的回答展示了如何将 DelegateDecompiler 插入 EF Core，相同的代码实际上可以用于插入其他（包括此处介绍的）基于自定义表达式访问者的预处理器。

重用排序逻辑

Reusing ordering logic

c#

linq

npgsql

entity-framework-core

.net-5