Paramètres Expression Lambda

Citation:

Envoyé par Dynas

Le code compile sans erreur mais le tri ne se fait pas.

Normal : tu tries selon quelque chose qui a la même valeur pour tous les items (quel que soit l'item, la valeur utilisée pour le tri est toujours ordreTri.listCol[x])

En fait, il faut générer dynamiquement les expressions lambda. C'est pas très évident, mais ça se fait... Voilà une implémentation assez basique (sous forme de méthodes d'extensions) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public static class QueryableExtensions
{
    public static IOrderedQueryable<T> OrderBy<T>(this IQueryable<T> source, string sortCriteria)
    {
        return source.AddSort(sortCriteria, _orderBy);
    }
 
    public static IOrderedQueryable<T> ThenBy<T>(this IOrderedQueryable<T> source, string sortCriteria)
    {
        return source.AddSort(sortCriteria, _thenBy);
    }
 
    private static readonly MethodInfo _orderBy = typeof(Queryable)
                            .GetMethods()
                            .Where(m => m.Name == "OrderBy" && m.GetParameters().Length == 2)
                            .First();
    private static readonly MethodInfo _thenBy = typeof(Queryable)
                            .GetMethods()
                            .Where(m => m.Name == "ThenBy" && m.GetParameters().Length == 2)
                            .First();
 
    private static IOrderedQueryable<T> AddSort<T>(this IQueryable<T> source, string sortCriteria, MethodInfo orderMethod)
    {
        Type criteriaType;
        var expr = MakeSelectorExpression<T>(sortCriteria, out criteriaType);
        var realMethod = orderMethod.MakeGenericMethod(typeof(T), criteriaType);
        return (IOrderedQueryable<T>)realMethod.Invoke(null, new object[] { source, expr });
    }
 
    static LambdaExpression MakeSelectorExpression<T>(string propertyName, out Type propertyType)
    {
        var param = Expression.Parameter(typeof(T));
        var body = Expression.Property(param, propertyName);
        var expr = Expression.Lambda(body, param);
        propertyType = body.Type;
        return expr;
    }
}

(note : ce n'est pas très optimisé ; il faudrait faire un système de cache pour ne pas utiliser MakeGenericMethod et Invoke à chaque fois... Si tu veux une implémentation un peu plus aboutie, jette un oeil à Dynamic Linq)

Tu peux l'utiliser comme ça :

Code:

1
2
3
4
5
      var result = List_Activite_DS
                    .AsQueryable()
                    .OrderBy(ordreTri.listCol[0])
                    .ThenBy(ordreTri.listCol[1])
                    .ThenBy(ordreTri.listCol[2]);

(note que je passe directement le nom de la propriété en paramètre, pas une expression lambda)

Et si tu ne connais pas à l'avance le nombre de critères :

Code:

1
2
3
4
5
6
7
8
9
10
var tmp = List_Activite_DS.AsQueryable();
foreach(var sortColumn in ordreTri.listCol)
{
    var ordered = tmp as IOrderedQueryable<CAC.Business.C_Activite>;
    if (ordered != null)
        tmp = ordered.ThenBy(sortColumn);
    else
        tmp = tmp.OrderBy(sortColumn);
}
var result = tmp;

Soit dit en passant, si tu fais le tri avec Linq, à quoi ça te sert d'utiliser SortableBindingList ? Tu pourrais gérer le tri directement avec SortableBindingList. (d'ailleurs, quelle implémentation de cette classe utilises-tu ? Ce n'est pas une classe du framework...)