Exemplo n.º 1
0
        private static IQueryable OrderByKey(this IQueryable queryable, bool ascending)
        {
            if (queryable == null)
            {
                throw new ArgumentNullException("queryable");
            }

            Expression orderedExpression = queryable.Expression;

            Type queryableElementType = queryable.ElementType;

            ParameterExpression parameter = queryable.CreateParameterExpression();

            MemberExpression sortMemberExpression = QueryableExtensions.GenerateMemberExpression(parameter, "Key");

            string methodName = (ascending) ? "OrderBy" : "OrderByDescending";

            orderedExpression = Expression.Call(typeof(Queryable),
                                                methodName,
                                                new Type[] { queryableElementType, sortMemberExpression.Type },
                                                orderedExpression, Expression.Quote(Expression.Lambda(sortMemberExpression, parameter)));

            return(queryable.Provider.CreateQuery(orderedExpression));
        }
Exemplo n.º 2
0
        internal static IQueryable OrderBy(
            this IQueryable queryable,
            SortDescriptionCollection implicitSortDescriptions,
            SortDescriptionCollection explicitSortDescriptions,
            bool reverse)
        {
            if (queryable == null)
            {
                throw new ArgumentNullException("queryable");
            }

            if ((implicitSortDescriptions == null) && (explicitSortDescriptions == null))
            {
                return(queryable);
            }

            Expression orderedExpression = queryable.Expression;

            Type queryableElementType = queryable.ElementType;

            ParameterExpression[] parameters = new ParameterExpression[] { Expression.Parameter(queryableElementType, "") };

            string ascendingOrderByMethodName  = "OrderBy";
            string descendingOrderByMethodName = "OrderByDescending";

            if (explicitSortDescriptions != null)
            {
                foreach (SortDescription sortDescription in explicitSortDescriptions)
                {
                    MemberExpression sortMemberExpression = QueryableExtensions.GenerateMemberExpression(parameters[0], sortDescription.PropertyName);

                    string methodNameToUse;

                    if ((sortDescription.Direction == ListSortDirection.Ascending && !reverse) || (sortDescription.Direction == ListSortDirection.Descending && reverse))
                    {
                        methodNameToUse = ascendingOrderByMethodName;
                    }
                    else
                    {
                        methodNameToUse = descendingOrderByMethodName;
                    }

                    orderedExpression = Expression.Call(typeof(Queryable),
                                                        methodNameToUse,
                                                        new Type[] { queryableElementType, sortMemberExpression.Type },
                                                        orderedExpression, Expression.Quote(Expression.Lambda(sortMemberExpression, parameters)));


                    ascendingOrderByMethodName  = "ThenBy";
                    descendingOrderByMethodName = "ThenByDescending";
                }
            }

            if (implicitSortDescriptions != null)
            {
                foreach (SortDescription sortDescription in implicitSortDescriptions)
                {
                    MemberExpression sortMemberExpression = QueryableExtensions.GenerateMemberExpression(parameters[0], sortDescription.PropertyName);

                    string methodNameToUse;

                    if ((sortDescription.Direction == ListSortDirection.Ascending && !reverse) || (sortDescription.Direction == ListSortDirection.Descending && reverse))
                    {
                        methodNameToUse = ascendingOrderByMethodName;
                    }
                    else
                    {
                        methodNameToUse = descendingOrderByMethodName;
                    }

                    orderedExpression = Expression.Call(typeof(Queryable),
                                                        methodNameToUse,
                                                        new Type[] { queryableElementType, sortMemberExpression.Type },
                                                        orderedExpression, Expression.Quote(Expression.Lambda(sortMemberExpression, parameters)));


                    ascendingOrderByMethodName  = "ThenBy";
                    descendingOrderByMethodName = "ThenByDescending";
                }
            }

            return(queryable.Provider.CreateQuery(orderedExpression));
        }