如何在LINQ查询中实现带排序方向参数的动态OrderBy

问题说明 #

要实现带orderBy（排序字段）和orderDirec（排序方向）参数的动态排序功能，直接在LINQ的orderby子句传入这两个字符串参数不会生效；自己写的扩展方法只能处理一级属性，没法解析T.FixedAssetDepreciation.Year这类嵌套属性的路径。

原业务方法代码：

public async Task<IPagedList<FixedAssetDepreciationDetail>> GetDepreciationDetailAsync(int companyId, string filterText = null,
            string orderBy = null, string orderDirec = "asc", int pageIndex = 0,
            int pageSize = int.MaxValue, int? fixedAssetID = null)
{
    var query = from a in _depreciationDetailRepository.Table
                join b in _depreciationRepository.Table on a.DepreciationID equals b.ID
                join c in _fixedAssetRepository.Table on a.FixedAssetID equals c.ID
                where b.IsActive && !b.IsDeleted
                && a.CompanyID == companyId
                && b.CompanyID == companyId
                && (a.FixedAssetID == fixedAssetID || fixedAssetID == null)
                orderby orderBy, orderDirec
                select FixedAssetDepreciationDetail.Build(a, c, b);
    return await query.ToPagedListAsync(pageIndex, pageSize, orderBy, orderDirec);
}

原扩展方法（不支持嵌套属性）：

public static class IOrderQueryable
{
    public static IQueryable<T> OrderByQuery<T>(this IQueryable<T> source, string dir, string sortColumn)
    {
        if (string.IsNullOrWhiteSpace(sortColumn))
            sortColumn = "ID";
        if (string.IsNullOrWhiteSpace(dir))
            dir = "ASC";
        Func<T, object> OrderByExp = GetOrderByExpression<T>(sortColumn);
        if (OrderByExp == null)
            return source;
        return dir.ToUpper() == "ASC" ? source.OrderBy(OrderByExp).AsQueryable() : source.OrderByDescending(OrderByExp).AsQueryable();
    }

    private static Func<T, object> GetOrderByExpression<T>(string sortColumn)
    {
        Func<T, object> orderByExpr = null;
        if (!string.IsNullOrEmpty(sortColumn))
        {
            Type sponsorResultType = typeof(T);
            if (sponsorResultType.GetProperties().Any(prop => prop.Name == sortColumn))
            {
                System.Reflection.PropertyInfo pinfo = sponsorResultType.GetProperty(sortColumn);
                orderByExpr = (data => pinfo.GetValue(data, null));
            }
        }
        return orderByExpr;
    }
}

解决方案：支持嵌套属性的动态OrderBy扩展方法 #

改进后的扩展方法通过构建表达式树解析嵌套属性路径，同时保证能被ORM（比如EF Core）转换成SQL执行，避免客户端评估：

using System.Linq.Expressions;
using System.Reflection;

public static class QueryableOrderByExtensions
{
    public static IQueryable<T> OrderByDynamic<T>(this IQueryable<T> source, string sortColumn, string sortDirection = "asc")
    {
        if (string.IsNullOrWhiteSpace(sortColumn))
        {
            sortColumn = "ID"; // 默认排序字段
        }
        sortDirection = string.IsNullOrWhiteSpace(sortDirection) ? "asc" : sortDirection.Trim().ToUpper();

        // 构建属性访问的表达式树
        var parameter = Expression.Parameter(typeof(T), "x");
        Expression propertyAccess = parameter;
        foreach (var propertyName in sortColumn.Split('.'))
        {
            PropertyInfo property = propertyAccess.Type.GetProperty(propertyName, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
            if (property == null)
            {
                // 找不到属性时返回原查询
                return source;
            }
            propertyAccess = Expression.Property(propertyAccess, property);
        }

        // 构建OrderBy/OrderByDescending的方法调用
        string methodName = sortDirection == "ASC" ? "OrderBy" : "OrderByDescending";
        var orderByMethod = typeof(Queryable).GetMethods()
            .First(m => m.Name == methodName && m.GetParameters().Length == 2)
            .MakeGenericMethod(typeof(T), propertyAccess.Type);

        return (IQueryable<T>)orderByMethod.Invoke(null, new object[] { source, Expression.Lambda(propertyAccess, parameter) });
    }
}

关键改进点 #

• 解析嵌套属性路径：用Split('.')拆分属性路径，逐层获取PropertyInfo，构建嵌套的属性访问表达式
• 表达式树构建：通过Expression类动态创建排序表达式，而非直接用反射GetValue（后者会导致LINQ无法转换成SQL，只能在客户端排序）
• 通用方法适配：通过反射获取Queryable的OrderBy/OrderByDescending泛型方法，适配不同的属性类型

业务方法中使用改进后的扩展 #

修改原业务方法，移除无效的orderby子句，改用扩展方法：

public async Task<IPagedList<FixedAssetDepreciationDetail>> GetDepreciationDetailAsync(int companyId, string filterText = null,
            string orderBy = null, string orderDirec = "asc", int pageIndex = 0,
            int pageSize = int.MaxValue, int? fixedAssetID = null)
{
    var query = from a in _depreciationDetailRepository.Table
                join b in _depreciationRepository.Table on a.DepreciationID equals b.ID
                join c in _fixedAssetRepository.Table on a.FixedAssetID equals c.ID
                where b.IsActive && !b.IsDeleted
                && a.CompanyID == companyId
                && b.CompanyID == companyId
                && (a.FixedAssetID == fixedAssetID || fixedAssetID == null)
                select FixedAssetDepreciationDetail.Build(a, c, b);

    // 应用动态排序
    query = query.OrderByDynamic(orderBy, orderDirec);

    return await query.ToPagedListAsync(pageIndex, pageSize);
}

注意：如果ToPagedListAsync内部也会处理排序，需要确认是否要移除其中的orderBy参数，避免重复排序。

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