Linq 动态排序（Reflection，Expression）要点记录_public static iqueryable<t> sort<t>(iqueryable<t> -优快云博客

本文链接：https://blog.youkuaiyun.com/stoneLSL/article/details/84862637

本文详细介绍了如何使用Reflection和Expression进行Linq动态排序，重点讲解了Expression.Call方法的运用，以及结合分页功能的操作步骤。通过获取属性集合、属性类型和名称，创建新的表达式，实现动态排序。同时，文章还涵盖了分页的实现方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

利用反射获取匹配到字段进行排序，附带一下分页

1.排序

            public static IQueryable<T> DataSort<T>(IQueryable<T> source, string fieldName, string sortDirection)
            {
                // 升序 or 降序
                string sortingDir = "OrderBy";
                if ( string.Equals(sortDirection.Trim(),"asc",StringComparison.OrdinalIgnoreCase))
                {
                    sortingDir = "OrderBy";
                }
                if (string.Equals(sortDirection.Trim(), "desc", StringComparison.OrdinalIgnoreCase))
                {
                    sortingDir = "OrderByDescending";
                }
                // 属性
                var orderField = string.Empty;
                Type t = typeof(T);
                var attributes = t.Attributes;
                var fields = t.GetFields();
                var properties = t.GetProperties();
                Type[] types = new Type[2];  //  参数：对象类型，属性类型
                types[0] = typeof(T);
                var isMatch = false;
                foreach (var p in properties)
                {
                    isMatch = string.Equals(fieldName, p.Name, StringComparison.OrdinalIgnoreCase);
                    if (isMatch)
                    {
                        orderField = p.Name;
                        types[1] = p.PropertyType;
                    }
                }
                if (!isMatch)
                {
                    types[1] = properties.First().PropertyType;
                    orderField = properties.First().Name;
                }
                PropertyInfo pi = typeof(T).GetProperty(orderField);
                ParameterExpression param = Expression.Parameter(typeof(T), orderField);
              
                Expression expr = Expression.Call(typeof(Queryable), sortingDir, types, 
                      source.Expression,   Expression.Lambda(Expression.Property(param, orderField),    param));
                IQueryable<T> query = source.AsQueryable().Provider.CreateQuery<T>(expr);
                return query;
            }

获取属性集合

Type t = typeof(T);
 var attributes = t.Attributes;
 var properties = t.GetProperties();

获取属性的类型和名称

  types[1] = properties.First().PropertyType;
 orderField = properties.First().Name;

关键点：调用了 Expression.Call 这个方法，用来创建新的表达式

参数说明：

  Call(Type type, 
  string methodName, 
  Type[] typeArguments, 
  params Expression[] arguments);

Type type：
Queryable对象类型（typeof(Queryable)）Queryable对象类型（typeof(Queryable)）
string methodName：
要执行的方法名（此处为：OrderBy or OrderByDescending）
Type[] typeArguments ：
类型参数，这里有2个，第一个为集合中的对象的类型，第二个为属性类型
params Expression[] arguments ：
多个Expression类型参数，这里有三个，
1. source.Expression，数据源（IQueryable）
2. Expression.Lambda(Expression.Property(param, orderField)
  Lambda参数表达式
3. param：
  参数表达式

需要的结果：创建新的表达式

 IQueryable<T> query = source.AsQueryable().Provider.CreateQuery<T>(expr);

2.分页

 public static IQueryable<T> DataPaging<T>(IQueryable<T> source, int pageNumber, int pageSize)
                {
                    return source.Skip(( Math.Abs(pageNumber)-1) * pageSize).Take(pageSize);
                }

3.排序加分页

            public static IQueryable<T> Sorting<T>(IQueryable<T> source, string fieldName, string sortDirection, int pageIndex, int pageSize)
            {
                IQueryable<T> query = DataSort<T>(source, fieldName, sortDirection);
                return DataPaging(query, pageIndex, pageSize);
            }