Passer une variable a la clause where

Bonjour tout le monde,

Voila, j'aimerais pouvoir passer une variable à la clause where dans une requête linq ! qql un a une idée ?

c'est quelque chose qui doit ressembler à ca : (mais comme ca ca ne marche pas !)

Code:

---

1 2 3 4 5 6 7

string where = "li.Titre.StartsWith(filtre.Text) && li.CategorieCode == categorie.Code" var Liste = from li in dc.tb_ where orderby li.NbrEcoute descending select li;

---

je rectifie le code pour que ca soit plus clair

Code:

---

1 2 3 4 5 6 7 8

public List<BO> Get(string where) { var Liste = from li in dc.tb where orderby li.MoyenneNote descending, li.NbrVote descending select li; }

---

Le principe du linq est d'avoir un typage fort et donc d'éviter de manipuler des chaine de caractere...

Il est possible par exemple de faire une méthode qui prendrait en argument une Expression Linq :

Code:

---

1 2 3 4 5 6

public List<BO> Get(Expression<Func<T, bool>> expression) { var Liste = from li in dc.tb.Where(expression) orderby li.MoyenneNote descending, li.NbrVote descending select li; }

---

et tu pourrais appeler la méthode comme cela :

Code:

---

var res = Get(e => e.MoyenneNote > 5 && e.MoyenneNote < 10);

---

Après si tu as réellement besoin de construire ta requête en dehors de la fonction il y a plusieurs possibilités :

- Créer un arbre d'expression Linq
- Utiliser du EQL
- Utiliser System.Linq.Dynamic

Tout d'abord merci pour ta réponse, elle m'a mit sur deux très bonnes pistes pour réaliser ce que je voudrais :ccool:.

Toutefois je vais quand même te dire ce que je voudrais faire exactement:

J'aimerais créer une fonction qui renvoie une liste de données et qui prends en paramètres Where et OrderBy. Quelle est la meilleure solution d'après toi ?
Et merci encore.

Pour l'orderby c'est un peu plus compliqué ... en effet un orderby peut être multiple et dans 2 directions différentes.

Ce problème m'a longtemps posé des soucis et j'ai fini par prendre une approche type "string".

Si tu utiliser System.Linq.dynamic (à télécharger) tu pourras faire ceci :

Code:

---

1 2 3 4

public List<BO> Get(Expression<Func<T, bool>> expression, string orderby) { return dc.tb.Where(expression).OrderBy(orderby).ToList(); }

---

Code:

---

var res = Get(e => e.MoyenneNote > 5 && e.MoyenneNote < 10, "MoyenneNote descending, NbrVote descending");

---

C'est la meilleur approche que j'ai trouvé, même si elle me satisfait pas beaucoup ...

Je vais bientôt faire un article sur le sujet sur mon blog tu peux t'abonner si tu veux ;)

OK je te remercie...

je veux bien m'abonner mais je trouve aucun lien le permettant !

Pour l'orderby pour continuer a utiliser la puissance des expressions je te conseil plutot ceci:

Code:

---

1 2 3 4 5

public IEnumerable<T> Get(Expression<Func<T, bool>> conditions, Expression<Func<T, IComparable>> order) { return T.Where(expression).OrderBy(order); }

---

avec pour l'order:

Code:

---

Func<T, IComparable> order = e => e.fieldName;

---

et voila ;)

mais attention !!! les expressions ne sont pas serializable en gros pour un development en architecture NTiers bonjour la galere je cherche encore une solution vivable (avec du typee fort, du cote client).

Citation:

---

Envoyé par zeavan

Pour l'orderby pour continuer a utiliser la puissance des expressions je te conseil plutot ceci:

Code:

---

1 2 3 4 5

public IEnumerable<T> Get(Expression<Func<T, bool>> conditions, Expression<Func<T, IComparable>> order) { return T.Where(expression).OrderBy(order); }

---

avec pour l'order:

Code:

---

Func<T, IComparable> order = e => e.fieldName;

---

et voila ;)

mais attention !!! les expressions ne sont pas serializable en gros pour un development en architecture NTiers bonjour la galere je cherche encore une solution vivable (avec du typee fort, du cote client).

---

Ce n'est pas une bonne approche pour l'orderby ...

En effet coment tu peux savoir si tu veux un ordre ascendant ou descendant (d'ailleurs dans son exemple c'est un order by descendant) et tu pourrais vouloir chainer plusieurs orderby mais ce n'est pas possible avec cette solution.

Une possibilité serai de creer une classe qui contiendrait un Func<T, IComparable> et un enum qui donne le sens de l'ordre et avoir une méthode dans ce style :

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 39

class Order { public Expression<Func<T, IComparable>> Selector { get; set; } public OrderDirection Direction { get; set; } }   public IEnumerable<T> Get(Expression<Func<T, bool>> expression, params Order[] orders) { var q = source.Where(expression); bool first = true; foreach(var order on orders) { if(order.Direction == OrderDirection.Ascending) { if(first) { q = q.OrderBy(order.Selector); } else { q = q.ThenBy(order.Selector); } } else { if(first) { q = q.OrderByDescending(order.Selector); } else { q = q.ThenByDescending(order.Selector); } } first =false; } return q.ToList(); }

---

Désolé pour l'indentation ...

Voila ca serait assez générique mais je trouve cela lourd à appeler (créer des objets Order)

Je préfère Linq dynamic ;-)

Merci pour cette precision anthyme et bonne chance pour ton blog.

Merci,

Je prépare quelque chose d'assez intéressant en ce moment : un framework Business autour de Linq, Unity, la POA, et l'IoC (un peu dans la ligné des SharpArchitecture, CSLA, rhino et j'en passe)

Le projet sera disponible en opensource sur codeplex et je me servirai de mon blog pour présenter tout ça :)