Discussion :

[Hafiz.B]

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 :

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

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;

[Hafiz.B]

je rectifie le code pour que ca soit plus clair

Code :

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

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

[anthyme]

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 :

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

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 :

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

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

[Hafiz.B]

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 .

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.

[anthyme]

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 :

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

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

Code :

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

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

[Hafiz.B]

OK je te remercie...

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

[zeavan]

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

Code :

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

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 :

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

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).

[anthyme]

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

Code :

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

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 :

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

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 :

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

[zeavan]

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

[anthyme]

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