c# ef 排序字段動態，構建動態Lambda和擴展方法OrderBy

1.動態構建排序 Lambda

        /// <summary>
        /// 獲取排序Lambda（如果動態排序，類型不同會導致轉換失敗）
        /// </summary>
        /// <typeparam name="T">數據字段類型</typeparam>
        /// <typeparam name="Tkey">排序字段類型</typeparam>
        /// <param name="defaultSort">默認的排序字段</param>
        /// <param name="sort">當前排序字段</param>
        /// <returns></returns>
        public static Expression<Func<T, Tkey>> SortLambda<T, Tkey>(string defaultSort, string sort)
        {
            //1.創建表達式參數（指定參數或變量的類型:p）  
            var param = Expression.Parameter(typeof(T), "t");
            //2.構建表達式體(類型包含指定的屬性:p.Name)  
            var body = Expression.Property(param, string.IsNullOrEmpty(sort) ? defaultSort : sort);
            //3.根據參數和表達式體構造一個lambda表達式  
            return Expression.Lambda<Func<T, Tkey>>(Expression.Convert(body, typeof(Tkey)), param);
        }

使用方法：

        public IQueryable<T> GetModelsByPage<Tkey>(int pageSize, int pageIndex, bool isAsc,
            Expression<Func<T, Tkey>> orderByLambda, Expression<Func<T, bool>> whereLambda, out int total)
        {
            total = dbContext.Set<T>().Where(whereLambda).Count();

            //是否升序
            if (isAsc)
            {
                return dbContext.Set<T>().Where(whereLambda).OrderBy(orderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize);
            }
            else
            {
                return dbContext.Set<T>().Where(whereLambda).OrderByDescending(orderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize);
            }
        }

缺點：Tkey必須限定，但不一定知道字段類型，錯誤的類型會導致轉換失敗，切返回值不能固定為object，如有其他方法，希望大牛給出建議。

---

 

2.對ef的OrderBy方法進行擴展（此方法無需指定類型）

    /// <summary>
    /// 查詢擴展方法
    /// </summary>
    public static class QueryableExtension
    {
        public static IOrderedQueryable<T> OrderBy<T>(this IQueryable<T> query, string propertyName)
        {
            return _OrderBy<T>(query, propertyName, false);
        }
        public static IOrderedQueryable<T> OrderByDescending<T>(this IQueryable<T> query, string propertyName)
        {
            return _OrderBy<T>(query, propertyName, true);
        }

        static IOrderedQueryable<T> _OrderBy<T>(IQueryable<T> query, string propertyName, bool isDesc)
        {
            string methodname = (isDesc) ? "OrderByDescendingInternal" : "OrderByInternal";

            var memberProp = typeof(T).GetProperty(propertyName);

            var method = typeof(QueryableExtension).GetMethod(methodname)
                                       .MakeGenericMethod(typeof(T), memberProp.PropertyType);

            return (IOrderedQueryable<T>)method.Invoke(null, new object[] { query, memberProp });
        }
        public static IOrderedQueryable<T> OrderByInternal<T, TProp>(IQueryable<T> query, System.Reflection.PropertyInfo memberProperty)
        {//public
            return query.OrderBy(_GetLamba<T, TProp>(memberProperty));
        }
        public static IOrderedQueryable<T> OrderByDescendingInternal<T, TProp>(IQueryable<T> query, System.Reflection.PropertyInfo memberProperty)
        {//public
            return query.OrderByDescending(_GetLamba<T, TProp>(memberProperty));
        }
        static Expression<Func<T, TProp>> _GetLamba<T, TProp>(System.Reflection.PropertyInfo memberProperty)
        {
            if (memberProperty.PropertyType != typeof(TProp)) throw new Exception();

            var thisArg = Expression.Parameter(typeof(T));
            var lamba = Expression.Lambda<Func<T, TProp>>(Expression.Property(thisArg, memberProperty), thisArg);

            return lamba;
        }
    }

使用方法：

        public IQueryable<T> GetModelsByPage(int pageSize, int pageIndex, bool isAsc, string orderByField, Expression<Func<T, bool>> whereLambda, out int total)
        {
            total = dbContext.Set<T>().Where(whereLambda).Count();

            //是否升序
            if (isAsc)
            {
                return dbContext.Set<T>().Where(whereLambda).OrderBy(orderByField).Skip((pageIndex - 1) * pageSize).Take(pageSize);
            }
            else
            {
                return dbContext.Set<T>().Where(whereLambda).OrderByDescending(orderByField).Skip((pageIndex - 1) * pageSize).Take(pageSize);
            }
        }

缺點：朕看不懂！