Discussion :

[GuiguiD]

Salut à tous et bonne année,

Je ramène ma pomme, je fais face à un problème épineux, je suis en train d'essayer de construire une expression dynamiquement que je passe à un service qui requête ma BD.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
private Expression<Func<EntityObject, bool>>? BuildSearchExpression()
{
    List<Expression<Func<EntityObject, bool>>> exprBuilderList = new List<Expression<Func<EntityObject, bool>>>();
 
    if (!string.IsNullOrWhiteSpace(filter.City))
    {
        if (filter.StringSearchChoice == StringSearchType.BeginBy)
            exprBuilderList.Add(x => x.Ville != null && x.Ville.ToLower().StartsWith(filter.City.ToLower()));
        if (filter.StringSearchChoice == StringSearchType.Contain)
            exprBuilderList.Add(x => x.Ville != null && x.Ville.ToLower().Contains(filter.City.ToLower()));
    }
 
    if (!string.IsNullOrWhiteSpace(filter.CompanyName))
    {
        if (filter.StringSearchChoice == StringSearchType.BeginBy)
            exprBuilderList.Add(x => x.NomEntreprise != null && x.NomEntreprise.ToLower().StartsWith(filter.CompanyName.ToLower()));
        if (filter.StringSearchChoice == StringSearchType.Contain)
            exprBuilderList.Add(x => x.NomEntreprise != null && x.NomEntreprise.ToLower().Contains(filter.CompanyName.ToLower()));
    }
 
    if (!string.IsNullOrWhiteSpace(filter.ContactName))
    {
        if (filter.StringSearchChoice == StringSearchType.BeginBy)
            exprBuilderList.Add(x => x.Contacts.Count > 0 && x.Contacts.Exists(con => (con.Prenom + " " + con.Nom).ToLower().StartsWith(filter.ContactName.ToLower())));
        if (filter.StringSearchChoice == StringSearchType.Contain)
            exprBuilderList.Add(x => x.Contacts.Count > 0 && x.Contacts.Exists(con => (con.Prenom + " " + con.Nom).ToLower().Contains(filter.ContactName.ToLower())));
    }
 
    if (!string.IsNullOrWhiteSpace(filter.Operator))
    {
        if (filter.StringSearchChoice == StringSearchType.BeginBy)
            exprBuilderList.Add(x => x.Operateur != null && x.Operateur.ToLower().StartsWith(filter.Operator.ToLower()));
        if (filter.StringSearchChoice == StringSearchType.Contain)
            exprBuilderList.Add(x => x.Operateur != null && x.Operateur.ToLower().Contains(filter.Operator.ToLower()));
    }
 
    if (!string.IsNullOrWhiteSpace(filter.PostalCode))
    {
        if (filter.StringSearchChoice == StringSearchType.BeginBy)
            exprBuilderList.Add(x => x.Cp != null && x.Cp.ToLower().StartsWith(filter.PostalCode.ToLower()));
        if (filter.StringSearchChoice == StringSearchType.Contain)
            exprBuilderList.Add(x => x.Cp != null && x.Cp.ToLower().Contains(filter.PostalCode.ToLower()));
    }
 
    if (!string.IsNullOrWhiteSpace(filter.PhoneNumber))
    {
        if (filter.StringSearchChoice == StringSearchType.BeginBy)
            exprBuilderList.Add(x => x.Tel != null && x.Tel.ToLower().StartsWith(filter.PhoneNumber.ToLower()));
        if (filter.StringSearchChoice == StringSearchType.Contain)
            exprBuilderList.Add(x => x.Tel != null && x.Tel.ToLower().Contains(filter.PhoneNumber.ToLower()));
    }
 
    if (filter.SheetNumber is not null)
        exprBuilderList.Add(x => x.NumFiche == filter.SheetNumber);
    if (filter.PartnerChoice != Partner.All)
        exprBuilderList.Add(x => x.Partenaire == Convert.ToBoolean((int)filter.PartnerChoice));
    if (filter.SchoolGrantOrCesu)
        exprBuilderList.Add(x => x.SubventionScolaireOuCesu == true);
 
// Premier essai: ça marche sur une expression évidemment mais pas quand 
// je les combine, une exception est levée : InvalidOperationException
// The binary operator AndAlso is not defined for the types 
// 'System.Func`2[Domain.Entities.EntityObject,System.Boolean]' and 
// 'System.Func`2[Domain.Entities.EntityObject,System.Boolean]'
// at System.Linq.Expressions.Expression.AndAlso(Expression left, Expression right, 
// MethodInfo method)
Expression < Func<EntityObject, bool>>? resultExpr = null;
    foreach (var expr in exprBuilderList)
    {
        if (resultExpr == null)
            resultExpr = expr;
        else
            resultExpr = Expression.Lambda<Func<EntityObject, bool>>(Expression.AndAlso(resultExpr, expr), expr.Parameters);
    }
    return resultExpr;
 
    // Mon dernier essai: ça lève direct une exception raising an exception of type System.ArgumentException 
    // en gros mon nombre de paramètres passés à ma lambda est incorrect 
    // Je sais pas vraiment quoi passer comme ParameterExpression ?
    Type delegateType = typeof(Func<,>).GetGenericTypeDefinition().MakeGenericType(typeof(EntityObject), typeof(bool));
 
    var combined = exprBuilderList.Count > 0 ? 
        exprBuilderList.Cast<Expression>().Aggregate((x, y) => Expression.AndAlso(x, y)) : 
        null;
 
    return combined != null ? (Expression<Func<EntityObject, bool>>)Expression.Lambda(delegateType, combined) : null;
}

Pour vous montrer tout le use case la méthode est appelée ici:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

var (count, result) = await service.GetObjectsAsync(state.Page, state.PageSize, BuildSearchExpression());

Et dans le service l'expression construite est utilisée simplement comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public async Task<(int, IEnumerable<myModel>)> GetObjectsAsync(int page, int pageSize, Expression<Func<EntityObject, bool>>? predicate = null)
{
        var query = predicate != null ? _context.EntityObjects.Where(predicate).Include(x => x.Child) : _context.EntityObjects.Include(x => x.Child);

Pour schématiser donc j'ai un modèle de filtre, quand je fais une recherche donc j'appelle la méthode BuildSearchExpression qui va construire dynamiquement une expression valide linq to sql en fonction des propriétés de l'objet filtre et requêter la BD.
Le problème vient à la fameuse agrégation des expressions en une seule. J'ai lu pas mal d'articles sur comment build un arbre d'expression, j'ai pas tout compris, mais les exemples que j'ai vu me paraissent vachement compliqués pour le truc simple que j'essai de faire.

Merci d'avance pour les conseils et l'aide.

[WDKyle]

Bonjour,

Il faut faire un AndAlso avec les expressions de la List et non avec la Lambda final qui doit être appelé qu'une fois.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
Expression < Func<EntityObject, bool>>? resultExpr = null;
 
    foreach (var expr in exprBuilderList)
    {
         resultExpr = resultExpr == null ? expr : Expression.AndAlso(resultExpr, expr);
    }
 
    return Expression.Lambda<Func<EntityObject, bool>>(resultExpr, expr, resultExpr.Parameters);

Je n'ai pas testé le code, mais vous voyez un peu l'idée

On construit dynamiquement l'agrégation des predicates puis on crée une lambdaExpression avec l'agrégat.