Créer LINQ to entities OrderBy expression à la volée

Je voulais partager ma mise en œuvre à l'aide de Jon réponse ci-dessus comme point de départ. Dans ce cas, plutôt que de tri par une propriété de chaîne de nom provenant de la couche de présentation (comme le titre de cette question n'est pas spécifique à ce sujet), je suis la création d'une Entité Cadre de la couche de données et vous souhaitez permettre à ses consommateurs à spécifier l'ordre par les propriétés les expressions lambda. I. E. Plutôt que de passer "sidx", je voulais être en mesure d'utiliser p => p.sidx. Je voulais aussi être en mesure de passer un nombre illimité d'ordre par les propriétés et être en mesure de spécifier l'ordre croissant ou décroissant.

Bien ma méthode peut accepter une telle expression lambda comme type Expression<Func<T, object>>. Que laissez-moi l'appeler comme je veux, mais le problème est, Entity Framework ne peut pas traduire l'expression SQL à moins que le second paramètre générique est fortement typé. Le OrderBy méthode d'extension nécessite deux paramètres génériques: T - le type de la propriété appartient à, et TKey - le type de la propriété renvoie. Donc, la première étape a été de modifier Jon exemple, pour convertir une donnée Expression<Func<T, object>> à un Expression<Func<T, Tkey>> (une fois que nous travaillons dans le cadre d'une requête, nous pouvons déterminer le type 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 });
}

Comme je l'ai mentionné, je veux accepter un nombre illimité de commande par sélecteurs à clé et ont également la possibilité de spécifier l'ordre croissant ou décroissant direction donc j'ai fait une classe wrapper pour le Expression<Func<T, object>> j'ai nommé 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; }
}

Puis j'ai mis à jour la méthode d'extension pour accueillir ce type et a créé une surcharge pour OrderBy qui reçoit un List<DynamicSortExpression<T>> et les ajoute à la requête à l'aide de la méthode d'extension(s) un par un. Voici le résultat final:

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 });
}
}

Maintenant, ma couche de données peut avoir une méthode comme List<T> GetList(Expression<Func<T, bool>> where, params DynamicSortExpression<T>[] orderBy) qui peut être appelée comme

new MyClass<Person>().GetList(p => p.FirstName == "Billy", //where clause
new DynamicSortExpression<T>(p => p.FirstName),
new DynamicSortExpression<T>(p => p.LastName, true));

La RemoveConvert méthode est quelque chose que j'ai tiré hors de la EntityFramework code source récursive de supprimer Convertir les appels à partir d'un 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;
}

J'espère que c'est utile! Merci Jon!

OriginalL'auteur xr280xr