LINQ OrderBy计算属性时查询无法翻译执行报错如何解决

你遇到的报错是EF Core无法将动态排序生成的、针对DTO计算属性的LINQ表达式翻译为可执行的SQL。根本原因是：

• 你先将数据库实体Invoice投影为GetInvoiceListDto后再执行排序，投影中的Due是纯内存计算属性，你自定义的OrderBy扩展方法生成的表达式是直接访问DTO的Due属性，EF Core无法反向映射到对应的数据库计算逻辑，因此翻译失败。
• 排序操作会被包含在整个查询的翻译逻辑中，因此执行Count()时就会触发翻译报错。

推荐按优先级选择以下方案：

方案1：调整查询执行顺序（最优，性能最好） #

将排序、计数、分页操作放在数据库实体层面执行，所有数据库操作完成后再做DTO投影，避免EF Core需要翻译DTO属性的逻辑：

public async Task<PaginatedList<GetInvoiceListDto>> Handle(GetInvoiceListQuery request, CancellationToken cancellationToken)
{
    var organisationId = _tenantService.GetOrganisationId();
    // 第一步：先构造数据库层面的查询，不做投影
    var query = _context.Invoices
        .Include(i => i.InvoiceSaleItems)
        .Include(i => i.Customer)
        .Where(w => w.OrganisationId == organisationId);
    
    // 第二步：对实体做动态排序，做列名映射把DTO的列对应到实体列
    string entitySortColumn = request.SortColumn switch
    {
        "Due" => nameof(Invoice.PaymentDueDate),
        "CustomerName" => $"{nameof(Invoice.Customer)}.{nameof(Customer.CustomerName)}",
        _ => request.SortColumn
    };
    // 注意Due的排序方向要翻转：Due升序 = PaymentDueDate降序，Due降序 = PaymentDueDate升序
    string entitySortOrder = request.SortColumn == "Due" 
        ? (request.SortOrder.Equals("asc", StringComparison.OrdinalIgnoreCase) ? "desc" : "asc") 
        : request.SortOrder;

    // 第三步：执行排序、计数、分页
    var sortedQuery = query.OrderBy(entitySortColumn, entitySortOrder);
    var count = await sortedQuery.CountAsync(cancellationToken);
    var items = await sortedQuery
        .Skip((request.PageNumber - 1) * request.PageSize)
        .Take(request.PageSize)
        // 最后再做投影
        .Select(y => new GetInvoiceListDto
        {
            Status = y.PaymentDueDate < DateTime.Now ? "Overdue" : "Sent",
            Due = (DateTime.Now - y.PaymentDueDate).TotalDays,
            InvoiceDate = y.InvoiceDate,
            InvoiceNumber = y.InvoiceNumber,
            CustomerName = y.Customer.CustomerName,
            AmountDue = y.InvoiceSaleItems.Sum(yx => yx.Amount) + y.InvoiceSaleItems.SelectMany(ss => ss.InvoiceSaleItemTaxes).Sum(sg => sg.Amount),
        }).ToListAsync(cancellationToken);

    return new PaginatedList<GetInvoiceListDto>(items, count, request.PageNumber, request.PageSize);
}

方案2：自定义计算列映射规则 #

如果需要适配更多DTO计算属性的排序，可以扩展你的OrderBy方法，支持传入属性映射字典，遇到指定属性时用对应的数据库可翻译表达式生成排序逻辑：

public static IQueryable<T> OrderBy<T>(this IQueryable<T> query, string sortColumn, string direction, Dictionary<string, Expression<Func<T, object>>> columnMappings = null)
{
    // 优先匹配自定义映射规则
    if (columnMappings != null && columnMappings.TryGetValue(sortColumn, out var mappingExp))
    {
        var methodName = direction.ToLower() == "asc" ? "OrderBy" : "OrderByDescending";
        var result = Expression.Call(
            typeof(Queryable),
            methodName,
            new[] { query.ElementType, mappingExp.Body.Type },
            query.Expression,
            Expression.Quote(mappingExp));
        return query.Provider.CreateQuery<T>(result);
    }
    // 原有普通列排序逻辑不变
    var methodNameFirst = string.Format("OrderBy{0}", direction.ToLower() == "asc" ? "" : "descending");
    var methodNameContinue = string.Format("ThenBy{0}", direction.ToLower() == "asc" ? "" : "descending");
    ParameterExpression parameter = Expression.Parameter(query.ElementType, "p");
    Expression resultExp = query.Expression;
    var currentMethodName = methodNameFirst;
    foreach (var fields in sortColumn.Split(','))
    {
        Expression memberAccess = null;
        foreach (var property in fields.Split('.'))
        {
            if (string.IsNullOrEmpty(property.Trim()) == false)
            {
                var newProp = "";
                if (property.IndexOf(" asc") == -1)
                {
                    newProp = property.Trim();
                }
                else
                {
                    newProp = property.Substring(0, property.IndexOf(" asc")).Trim();
                }
                try
                {
                    memberAccess = MemberExpression.Property(memberAccess ?? (parameter as Expression), newProp);
                }
                catch 
                {
                    continue;
                }
            }
        }
        if(memberAccess == null) continue;
        LambdaExpression orderByLambda = Expression.Lambda(memberAccess, parameter);
        resultExp = Expression.Call(
            typeof(Queryable),
            currentMethodName,
            new[] { query.ElementType, memberAccess.Type },
            resultExp,
            Expression.Quote(orderByLambda));
        currentMethodName = methodNameContinue;
    }
    return query.Provider.CreateQuery<T>(resultExp);
}

方案3：客户端评估（仅适合数据量极小的场景） #

如果不想调整原有逻辑，可以在排序前先将查询加载到内存，所有计算、排序都在内存执行，缺点是数据量大时性能极差：

// 仅需在投影后增加切换客户端评估的调用即可
return await _context.Invoices
    .Include(i => i.InvoiceSaleItems)
    .Where(w => w.OrganisationId == organisationId)
    .Select(y => new GetInvoiceListDto
    {
        // 投影逻辑保持不变
        Status = y.PaymentDueDate < DateTime.Now ? "Overdue" : "Sent",
        Due = (DateTime.Now - y.PaymentDueDate).TotalDays,
        InvoiceDate = y.InvoiceDate,
        InvoiceNumber = y.InvoiceNumber,
        CustomerName = y.Customer.CustomerName,
        AmountDue = y.InvoiceSaleItems.Sum(yx => yx.Amount) + y.InvoiceSaleItems.SelectMany(ss => ss.InvoiceSaleItemTaxes).Sum(sg => sg.Amount),
    })
    .AsEnumerable() // 强制切换到客户端计算
    .AsQueryable()
    .PaginatedListAsync(request.PageNumber, request.PageSize, request.SortColumn, request.SortOrder, request.q);

• 原有代码中的Count()是同步方法，建议换成await CountAsync()避免线程阻塞
• 原有PaginatedListAsync中Task.FromResult(query.ToList())是同步执行，建议换成await query.ToListAsync()提升异步性能

内容的提问来源于stack exchange，提问作者ecasper