Entity Framework 第七篇 简化排序

上篇介绍了EF的分页实现，分页的时候会用到排序，但是使用起来表达式写的似乎很繁琐

var a = respository.GetPaged<S_Users>(out count, m => m.LoginName.Contains("a"), q => q.OrderBy(m => m.LastDate).ThenByDescending(m=>m.LoginNum),1, 20);

如果直接使用排序字符串，不更直观简便么？

            respository.GetPaged<S_Users>(out count, m => m.LoginName.Contains("a"),"LoginName asc,LoginNum desc", 1, 20);

可以通过扩展方法来实现

 public static class QueryExtensions
    {
        public static IQueryable<T> OrderBy<T>(this IQueryable<T> source, string sortExpressions)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            string sortDirection = String.Empty;
            string propertyName = String.Empty;

            sortExpressions = sortExpressions.Trim();

            string[] sorts = sortExpressions.Split(',');
            for (int i = 0; i < sorts.Length; i++)
            {
                string sortExpression = sorts[i];
                int spaceIndex = sortExpression.Trim().IndexOf(" ");
                if (spaceIndex < 0)
                {
                    propertyName = sortExpression;
                    sortDirection = "ASC";
                }
                else
                {
                    propertyName = sortExpression.Substring(0, spaceIndex);
                    sortDirection = sortExpression.Substring(spaceIndex + 1).Trim();
                }

                if (String.IsNullOrEmpty(propertyName))
                {
                    return source;
                }

                ParameterExpression parameter = Expression.Parameter(source.ElementType, String.Empty);
                MemberExpression property = Expression.Property(parameter, propertyName);
                LambdaExpression lambda = Expression.Lambda(property, parameter);

                string methodName = string.Empty;
                if (i == 0)
                {
                    methodName = (sortDirection.ToUpper() == "ASC") ? "OrderBy" : "OrderByDescending";
                }
                else
                {
                    methodName = (sortDirection.ToUpper() == "ASC") ? "ThenBy" : "ThenByDescending";
                }

                Expression methodCallExpression = Expression.Call(typeof(Queryable), methodName,
                                                    new Type[] { source.ElementType, property.Type },
                                                    source.Expression, Expression.Quote(lambda));

                source = source.Provider.CreateQuery<T>(methodCallExpression);

            }
            return source;

        }
    }