/// <summary>
/// Sorts the elements of a sequence in ascending or decsending order according to a key.
/// </summary>
/// <param name="source">A sequence of values to order.</param>
/// <param name="ordering">An expression string to indicate values to order by.</param>
/// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similiar to the way String.Format formats strings.</param>
/// <returns>A <see cref="IQueryable"/> whose elements are sorted according to the specified <paramref name="ordering"/>.</returns>
/// <example>
/// <code>
/// var result = list.OrderBy("NumberProperty, StringProperty DESC");
/// </code>
/// </example>
public static IQueryable OrderBy(this IQueryable source, string ordering, params object[] args)
{
Validate.Argument(source, "source").IsNotNull().Check()
.Argument(ordering, "ordering").IsNotNull().IsNotEmpty().IsNotWhiteSpace().Check();
ParameterExpression[] parameters = new ParameterExpression[] {
Expression.Parameter(source.ElementType, "")
};
ExpressionParser parser = new ExpressionParser(parameters, ordering, args);
IEnumerable <DynamicOrdering> orderings = parser.ParseOrdering();
Expression queryExpr = source.Expression;
string methodAsc = "OrderBy";
string methodDesc = "OrderByDescending";
foreach (DynamicOrdering o in orderings)
{
queryExpr = Expression.Call(
typeof(Queryable), o.Ascending ? methodAsc : methodDesc,
new Type[] { source.ElementType, o.Selector.Type },
queryExpr, Expression.Quote(Expression.Lambda(o.Selector, parameters)));
methodAsc = "ThenBy";
methodDesc = "ThenByDescending";
}
return(source.Provider.CreateQuery(queryExpr));
}
public static IQueryable OrderBy(this IQueryable source, string ordering, params object[] values)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (ordering == null)
{
throw new ArgumentNullException("ordering");
}
ParameterExpression[] parameters = new ParameterExpression[] {
Expression.Parameter(source.ElementType, "")
};
ExpressionParser parser = new ExpressionParser(parameters, ordering, values);
IEnumerable <DynamicOrdering> orderings = parser.ParseOrdering();
Expression queryExpr = source.Expression;
string methodAsc = "OrderBy";
string methodDesc = "OrderByDescending";
foreach (DynamicOrdering o in orderings)
{
queryExpr = Expression.Call(
typeof(Queryable), o.Ascending ? methodAsc : methodDesc,
new Type[] { source.ElementType, o.Selector.Type },
queryExpr, Expression.Quote(Expression.Lambda(o.Selector, parameters)));
methodAsc = "ThenBy";
methodDesc = "ThenByDescending";
}
return(source.Provider.CreateQuery(queryExpr));
}
/// <summary>
/// Sorts the elements of a sequence in ascending or descending order according to a key.
/// </summary>
/// <param name="source">A sequence of values to order.</param>
/// <param name="ordering">An expression string to indicate values to order by.</param>
/// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
/// <returns>A <see cref="IQueryable"/> whose elements are sorted according to the specified <paramref name="ordering"/>.</returns>
/// <example>
/// <code>
/// var result = list.OrderBy("NumberProperty, StringProperty DESC");
/// </code>
/// </example>
public static IOrderedQueryable OrderBy(this IQueryable source, string ordering, params object[] args)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (string.IsNullOrEmpty(ordering?.Trim()))
{
throw new ArgumentNullException(nameof(ordering)); //string.IsNullOrWhiteSpace not available in NET35
}
ParameterExpression[] parameters = new ParameterExpression[] {
Expression.Parameter(source.ElementType, "")
};
ExpressionParser parser = new ExpressionParser(parameters, ordering, args);
IEnumerable <DynamicOrdering> orderings = parser.ParseOrdering();
Expression queryExpr = source.Expression;
string methodAsc = "OrderBy";
string methodDesc = "OrderByDescending";
foreach (DynamicOrdering o in orderings)
{
queryExpr = Expression.Call(
typeof(Queryable), o.Ascending ? methodAsc : methodDesc,
new Type[] { source.ElementType, o.Selector.Type },
queryExpr, Expression.Quote(Expression.Lambda(o.Selector, parameters)));
methodAsc = "ThenBy";
methodDesc = "ThenByDescending";
}
return((IOrderedQueryable)source.Provider.CreateQuery(queryExpr));
}
public static IQueryable <T> OrderBy <T>(this IQueryable <T> source, string ordering, params object[] values)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (ordering == null)
{
throw new ArgumentNullException("ordering");
}
var parameters = new[]
{
Expression.Parameter(source.ElementType, "")
};
var parser = new ExpressionParser(parameters, ordering, values);
var orderings = parser.ParseOrdering();
object result = source;
var helperMethodName = "OrderByHelper";
foreach (var order in orderings)
{
var keySelectorExpression = Expression.Lambda(
order.Selector,
order.Parameter
);
var orderByHelperMethod = typeof(DynamicQueryable)
.GetMethod(helperMethodName, BindingFlags.NonPublic | BindingFlags.Static)
.MakeGenericMethod(typeof(T), order.Selector.Type);
result = orderByHelperMethod.Invoke(null, new object[] { result, keySelectorExpression, order.Ascending });
helperMethodName = "ThenByHelper";
}
return((IOrderedQueryable <T>)result);
}
public static IQueryable OrderBy(this IQueryable source, string ordering, params object[] values)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (ordering == null)
{
throw new ArgumentNullException("ordering");
}
ParameterExpression[] parameters = new ParameterExpression[]
{
Expression.Parameter(source.ElementType, "")
};
ExpressionParser expressionParser = new ExpressionParser(parameters, ordering, values);
IEnumerable <DynamicOrdering> enumerable = expressionParser.ParseOrdering();
Expression expression = source.Expression;
string text = "OrderBy";
string text2 = "OrderByDescending";
foreach (DynamicOrdering current in enumerable)
{
expression = Expression.Call(typeof(Queryable), current.Ascending ? text : text2, new Type[]
{
source.ElementType,
current.Selector.Type
}, new Expression[]
{
expression,
Expression.Quote(Expression.Lambda(current.Selector, parameters))
});
text = "ThenBy";
text2 = "ThenByDescending";
}
return(source.Provider.CreateQuery(expression));
}
public static IQueryable OrderBy(this IQueryable source, string ordering, QueryResolver queryResolver)
{
if (source == null)
throw new ArgumentNullException("source");
if (ordering == null)
throw new ArgumentNullException("ordering");
ParameterExpression[] parameters = new ParameterExpression[] {
Expression.Parameter(source.ElementType, "") };
ExpressionParser parser = new ExpressionParser(parameters, ordering, queryResolver);
IEnumerable<DynamicOrdering> orderings = parser.ParseOrdering();
Expression queryExpr = source.Expression;
string methodAsc = "OrderBy";
string methodDesc = "OrderByDescending";
foreach (DynamicOrdering o in orderings)
{
queryExpr = Expression.Call(
typeof(Queryable), o.Ascending ? methodAsc : methodDesc,
new Type[] { source.ElementType, o.Selector.Type },
queryExpr, Expression.Quote(DynamicExpression.Lambda(o.Selector, parameters)));
methodAsc = "ThenBy";
methodDesc = "ThenByDescending";
}
return source.Provider.CreateQuery(queryExpr);
}
