Я хотел бы поделиться своей реализацией, используя ответ Джона выше в качестве отправной точки. В этом случае, вместо того, чтобы сортировать по имени свойства строки, полученному из уровня представления (так как заголовок этого вопроса не является определенным в этом отношении), я строю слой данных Entity Framework и хочу, чтобы его потребитель указал порядок по свойствам как лямбда-выражения. И.Е. Вместо того, чтобы передать "sidx", я хотел иметь возможность использовать p => p.sidx. Я также хотел иметь возможность передавать неограниченное количество заказов по свойствам и указывать возрастающий или убывающий порядок.
Ну, мой метод может принять такое лямбда-выражение как тип Expression<Func<T, object>>. Это позвольте мне назвать это так, как я хочу, но проблема в том, что Entity Framework не может перевести выражение в SQL, если второй обобщенный параметр не является строго типизированным. Для метода расширения OrderBy требуются два общих параметра: T - тип, к которому принадлежит свойство, и TKey - тип, который возвращает свойство. Итак, первым шагом было изменение примера Джона для преобразования данного Expression<Func<T, object>> в Expression<Func<T, Tkey>> (как только мы работаем в контексте запроса, мы можем определить тип TKey):
internal static IQueryable<T> OrderByDynamic<T>(this IQueryable<T> source, Expression<Func<T, object>> sortExp)
{
//We need to convert the key selector from Expression<Func<T, object>> to a strongly typed Expression<Func<T, TKey>>
//in order for Entity Framework to be able to translate it to SQL
MemberExpression orderByMemExp = ExpressionHelpers.RemoveConvert(sortExp.Body) as MemberExpression;
ParameterExpression sourceParam = sortExp.Parameters[0];
LambdaExpression orderByLamda = Expression.Lambda(orderByMemExp, new[] { sourceParam });
MethodInfo orderByMethod = OrderByMethod.MakeGenericMethod(new[] { typeof(T), orderByMemExp.Type });
//Call OrderBy or OrderByDescending on the source IQueryable<T>
return (IQueryable<T>)orderByMethod.Invoke(null, new object[] { source, orderByLamda });
}
Как я уже говорил, я хочу принимать неограниченное количество заказов по ключевым селекторам, а также иметь возможность указывать восходящее или нисходящее направление, поэтому я создал класс-оболочку для Expression<Func<T, object>>, который я назвал DynamicSortExpression:
public class DynamicSortExpression<T>
{
/// <summary>
/// Creates a new ascending DynamicSortExpression
/// </summary>
/// <param name="keySelector">A MemberExpression identifying the property to sort on</param>
public DynamicSortExpression(Expression<Func<T, object>> keySelector) : this(keySelector, false)
{
}
public DynamicSortExpression(Expression<Func<T, object>> keySelector, bool descending)
{
this.KeySelector = keySelector;
this.Desc = descending;
}
/// <summary>
/// Gets the expression that selects the property of T to sort on
/// </summary>
public Expression<Func<T, object>> KeySelector { get; }
/// <summary>
/// Gets sort expression is in ascending or descending order
/// </summary>
public bool Desc { get; }
}
Затем я обновил метод расширения, чтобы принять этот тип, и создал перегрузку для OrderBy, которая получает List<DynamicSortExpression<T>> и добавляет их в запрос, используя методы расширения один за другим. Вот окончательный результат:
public static class Extensions
{
private static readonly MethodInfo OrderByMethod = typeof(Queryable).GetMethods()
.Where(method => method.Name == "OrderBy")
.Where(method => method.GetParameters().Length == 2)
.Single();
private static readonly MethodInfo OrderByDescMethod = typeof(Queryable).GetMethods()
.Where(method => method.Name == "OrderByDescending")
.Where(method => method.GetParameters().Length == 2)
.Single();
private static readonly MethodInfo ThenByMethod = typeof(Queryable).GetMethods()
.Where(method => method.Name == "ThenBy")
.Where(method => method.GetParameters().Length == 2)
.Single();
private static readonly MethodInfo ThenByDescMethod = typeof(Queryable).GetMethods()
.Where(method => method.Name == "ThenByDescending")
.Where(method => method.GetParameters().Length == 2)
.Single();
internal static IQueryable<T> OrderBy<T>(this IQueryable<T> sourceQuery, List<DynamicSortExpression<T>> orderBy)
{
bool isFirst = true;
foreach (var sortExpression in orderBy)
{
if (isFirst)
{
sourceQuery = sourceQuery.OrderByDynamic(sortExpression);
isFirst = false;
}
else
sourceQuery = sourceQuery.ThenByDynamic(sortExpression);
}
return sourceQuery;
}
internal static IQueryable<T> OrderByDynamic<T>(this IQueryable<T> source, DynamicSortExpression<T> sortExpression)
{
//We need to convert the key selector from Expression<Func<T, object>> to a strongly typed Expression<Func<T, TKey>>
//in order for Entity Framework to be able to translate it to SQL
MemberExpression orderByMemExp = ExpressionHelpers.RemoveConvert(sortExpression.KeySelector.Body) as MemberExpression;
ParameterExpression sourceParam = sortExpression.KeySelector.Parameters[0];
LambdaExpression orderByLamda = Expression.Lambda(orderByMemExp, new[] { sourceParam });
MethodInfo orderByMethod = sortExpression.Desc ?
OrderByDescMethod.MakeGenericMethod(new[] { typeof(T), orderByMemExp.Type }) :
OrderByMethod.MakeGenericMethod(new[] { typeof(T), orderByMemExp.Type });
//Call OrderBy or OrderByDescending on the source IQueryable<T>
return (IQueryable<T>)orderByMethod.Invoke(null, new object[] { source, orderByLamda });
}
internal static IQueryable<T> ThenByDynamic<T>(this IQueryable<T> source, DynamicSortExpression<T> sortExpression)
{
//We need to convert the key selector from Expression<Func<T, object>> to a strongly typed Expression<Func<T, TKey>>
//in order for Entity Framework to be able to translate it to SQL
Expression orderByMemExp = ExpressionHelpers.RemoveConvert(sortExpression.KeySelector.Body) as MemberExpression;
ParameterExpression sourceParam = sortExpression.KeySelector.Parameters[0];
LambdaExpression orderByLamda = Expression.Lambda(orderByMemExp, new[] { sourceParam });
MethodInfo orderByMethod = sortExpression.Desc ?
ThenByDescMethod.MakeGenericMethod(new[] { typeof(T), orderByMemExp.Type }) :
ThenByMethod.MakeGenericMethod(new[] { typeof(T), orderByMemExp.Type });
//Call OrderBy or OrderByDescending on the source IQueryable<T>
return (IQueryable<T>)orderByMethod.Invoke(null, new object[] { source, orderByLamda });
}
}
Теперь мой слой данных может иметь метод, подобный List<T> GetList(Expression<Func<T, bool>> where, params DynamicSortExpression<T>[] orderBy), который может быть вызван как
new MyClass<Person>().GetList(p => p.FirstName == "Billy", //where clause
new DynamicSortExpression<T>(p => p.FirstName),
new DynamicSortExpression<T>(p => p.LastName, true));
Метод RemoveConvert - это то, что я вырвал из исходного кода EntityFramework для рекурсивного удаления вызовов Convert из MemberExpression:
internal static Expression RemoveConvert(Expression expression)
{
System.Diagnostics.Debug.Assert(expression != null);
while ((expression != null)
&& (expression.NodeType == ExpressionType.Convert
|| expression.NodeType == ExpressionType.ConvertChecked))
{
expression = RemoveConvert(((UnaryExpression)expression).Operand);
}
return expression;
}
Надеюсь, это полезно! Спасибо Джон!