Etude exploratoire de Linq - CoDE - de l'Université libre de Bruxelles

2.2.2 Expressions lambda
Cette sous-section rassemble également des informations provenant de [1] et de [6]. Le type
delegate introduit avec la version 2 du framework .NET représente un moyen de faire pointer du
code vers une fonction définie ailleurs. L’expression lambda simplifie cette pratique et permet plus
de souplesse à l’utilisation. Ceci s’avère particulièrement utile pour l’écriture de méthodes
anonymes, comme le montre l’exemple suivant (trouvé sur [6]) :
//methode anonyme recuperant les entiers positifs, ecrite avec la
//syntaxe 2.0
List list = new List(new int[] { -1, 2, -5, 45, 5 });
List positiveNumbers = list.FindAll(delegate(int i) { return i >
0; });
//meme code ecrit avec une expression lambda
List list = new List(new int[] { -1, 2, -5, 45, 5 });
var positiveNumbers = list.FindAll((int i) => i > 0);
La syntaxe d’une expression lambda est toute simple. Elle se compose d’une liste de paramètres (un
seul, dans l’exemple ci-dessus, l’entier i), du symbole « => » intuitivement traduit par « tel que » et
d’une expression qui constitue en fait la valeur retournée par l’expression lambda. Cette formulation
est bien plus lisible et se prononce « tous les entiers i tels que la valeur de i est strictement
supérieure à 0 ». Un autre avantage est que la valeur retournée par l’expression lambda est typée
implicitement, comme l’indique le mot-clé var dans l’exemple précédent.
En plus d’une simplicité d’écriture pour les méthodes anonymes, les expressions lambda permettent
de traiter des expressions proches des clauses Sql. Ainsi une clause Where dans une requête Sql peut
se voir comme une condition de filtrage du résultat. Pour exprimer ceci en termes d’expressions
lambda, nous appelons notre condition de filtrage définie par une expression lambda sur le résultat,
de cette manière résultat.Filtrage(conditions). Le résultat de ce filtrage peut être lui-même soumis à
d’autres opérations de ce type, présentant l’avantage de pouvoir lire les opérations séquentiellement
de gauche à droite : résultat.Filtre1( condition1.1, condition1.2).Filtre2( condition2.1, … condition2.n)
et ainsi de suite. C’est ainsi que Linq en fait usage, pour passer à chaque opérateur de clause le
résultat créé par l’appel des clauses précédentes : EnsembleFrom.Where(clause where).Select(clause
select).OrderBy(critère de tri). Nous ne parlons ici que des clauses au sens relationnel du terme, le Sql
étant devenu en quelque sorte le standard pour interroger des données, nous nous contentons
d’utiliser ici l’analogie. Nous verrons plus loin que Linq a adopté une syntaxe qui en est très proche.
2.2.3 Expressions arborescentes
Agir sur une source de données implique de pouvoir naviguer, disons, parmi les nœuds de sa
structure. La notion de relation entre des données stockées caractérise ceci au niveau conceptuel,
mais en pratique, qu’en est-il ? Pour des collections d’objets en mémoire, des itérateurs ou des
méthodes de saut à un autre élément sont généralement fournis par la collection elle-même. Pour
une structure relationnelle, les relations sont réalisées par des jointures entre plusieurs tables. Aucun
mécanisme orienté objet ne permet d’appeler une fonction qui sautera directement vers l’élément
désiré. Le problème est le même lorsqu’on manipule des données en Xml bien que, dans ce cas, la
syntaxe des requêtes soit plus proche du paradigme objet. Pour résoudre ce problème, les
expressions arborescentes (expression tree, en Anglais) ont vu le jour. L’intérêt n’est pas tant de
manipuler en soi la source de données mais plutôt de pouvoir naviguer dans un résultat et surtout
dans une requête. Comprendre la notion de jointure est indispensable pour écrire une requête qui y