LINQ: Tri dynamique sur plusieurs colonnes

Question

J'ai une requête de IQueryable et je veux y appliquer un tri dynamiquement, le tri peut être sur plusieurs colonnes (asc ou desc). J'ai écrit la fonction générique suivante:

private IQueryable<T> ApplySorting<T,U>(IQueryable<T> query, Expression<Func<T, U>> predicate, SortOrder order) 
    { 
     if (order == SortOrder.Ascending) 
     { 
      { 
       return query.OrderBy<T, U>(predicate); 
      } 
     } 
     else 
     { 
      { 
       return query.OrderByDescending<T, U>(predicate); 
      } 
     } 
    } 

SortOrder est mon simple, ENUM avec 2 valeurs: ascendant et descendant

J'appelle cette fonction dans une boucle, pour chaque colonne que l'utilisateur a demandé le tri. Cependant j'ai remarqué qu'il échoue parce qu'il trie toujours sur la dernière colonne utilisée, en ignorant les autres.

Je trouve qu'il ya une méthode « ThenBy » sur IOrderedQueryable si l'usage est valide:

var q = db.MyType.OrderBy(x=>x.Col1).ThenBy(y=>y.Col2); //etc. 

Mais comment puis-je faire générique? J'ai essayé de tester si la requête est IOrderedQueryable mais elle semble toujours être vraie même si c'est la plus simple var q = de x dans db.MyType select x

Je n'ai aucune idée pourquoi il a été conçu comme ceci. Quel est le problème avec:

var q = db.MyType.OrderBy(x=>x.Col1).OrderBy(y=>y.Col2); //etc. 

il est tellement intuitive

Answer 1

estimation totale, mais pouvez-vous faire quelque chose comme ça?

query.OrderBy(x => 1).ThenBy<T,U>(predicate) 

Les erreurs de syntaxe mises à part, l'idée est de faire une OrderBy() qui ne touche rien, alors faire le travail réel dans l'appel de méthode .ThenBy()

Answer 2

Vous avez juste besoin de vérifier si la requête est déjà commandée:

private IQueryable<T> ApplySorting<T,U>(IQueryable<T> query, Expression<Func<T, U>> predicate, SortOrder order) 
{ 
    var ordered = query as IOrderedQueryable<T>; 
    if (order == SortOrder.Ascending) 
    { 
     if (ordered != null) 
      return ordered.ThenBy(predicate); 
     return query.OrderBy(predicate); 
    } 
    else 
    { 
     if (ordered != null) 
      return ordered.ThenByDescending(predicate); 
     return query.OrderByDescending(predicate); 
    } 
} 

Answer 3

J'écrirais un wrapper et j'utiliserais en interne des méthodes d'extension linq.

var resultList = presentList 
     .MyOrderBy(x => x.Something) 
     .MyOrderBY(y => y.SomethingElse) 
     .MyOrderByDesc(z => z.AnotherThing) 

public IQueryable<T> MyOrderBy(IQueryable<T> prevList, Expression<Func<T, U>> predicate) { 

     return (prevList is IOrderedQueryable<T>) 
      ? query.ThenBy(predicate) 
      : query.OrderBy(predicate); 
} 

public IQueryable<T> MyOrderByDesc(IQueryable<T> prevList, Expression<Func<T, U>> predicate) { 

     return (prevList is IOrderedQueryable<T>) 
      ? query.ThenByDescending(predicate) 
      : query.OrderByDescending(predicate); 
} 

PS: Je n'ai pas testé le code

Answer 4

Extension multi-ordre dynamique:

public static class DynamicExtentions 
{ 
    public static IEnumerable<T> DynamicOrder<T>(this IEnumerable<T> data, string[] orderings) where T : class 
    { 
     var orderedData = data.OrderBy(x => x.GetPropertyDynamic(orderings.First())); 
     foreach (var nextOrder in orderings.Skip(1)) 
     { 
      orderedData = orderedData.ThenBy(x => x.GetPropertyDynamic(nextOrder)); 
     } 
     return orderedData; 
    } 

    public static object GetPropertyDynamic<Tobj>(this Tobj self, string propertyName) where Tobj : class 
    { 
     var param = Expression.Parameter(typeof(Tobj), "value"); 
     var getter = Expression.Property(param, propertyName); 
     var boxer = Expression.TypeAs(getter, typeof(object)); 
     var getPropValue = Expression.Lambda<Func<Tobj, object>>(boxer, param).Compile();    
     return getPropValue(self); 
    } 
} 

Exemple:

var q =(myItemsToSort.Order(["Col1","Col2"]); 

Remarque: pas sûr tout fournisseur IQueryable peut traduire ceci

Answer 5

Que diriez-vous de faire le premier OrderBy statique, alors toujours ThenBy?

OrderColumn[] columnsToOrderby = getColumnsToOrderby(); 
IQueryable<T> data = getData(); 

if(!columnToOrderBy.Any()) { } 
else 
{ 
    OrderColumn firstColumn = columnsToOrderBy[0]; 
    IOrderedEnumerable<T> orderedData = 
     firstColumn.Ascending 
     ? data.OrderBy(predicate) 
     : data.OrderByDescending(predicate); 

    for (int i = 1; i < columnsToOrderBy.Length; i++) 
    { 
     OrderColumn column = columnsToOrderBy[i]; 
     orderedData = 
      column.Ascending 
      ? orderedData.ThenBy(predicate) 
      : orderedData.ThenByDescending(predicate); 
    } 
}