Afin de commencer cette article, commençons par une petite devinette.
Quel sont les résultats de ces deux morceaux de code :
var actions = new List<Action>(); for (int i = 0; i < 10; i++) actions.Add(() => Console.WriteLine(i)); foreach (var action in actions) action(); |
var actions = new List<Action>(); for (int i = 0; i < 10; i++) { int j = i; actions.Add(() => Console.WriteLine(j)); } foreach (var action in actions) action(); |
La première réponse que vous avez du vous faire est que ces deux codes ont le même résultat : afficher les nombres de 0 à 9. En effet, on met des méthodes délégués dans une liste de délégués puis on parcourt cette liste afin d’exécuter le code de ces délégués. La seule différence entre les deux codes est l’utilisation d ‘une variable local j.
Et pourtant la réponse est :
- Exemple 1 : 10 10 10 10 10 10 10 10 10 10
- Exemple 2 : 0 1 2 3 4 5 6 7 8 9
Autre exemple dans le même genre :
var actions = new List<Action>(); string[] urls = { "http://www.url.com", "http://www.someurl.com", "http://www.someotherurl.com", "http://www.yetanotherurl.com" }; for (int i = 0; i < urls.Length; i++) { actions.Add(() => Console.WriteLine(urls[i])); } |
var actions = new List<Action>(); string[] urls = { "http://www.url.com", "http://www.someurl.com", "http://www.someotherurl.com", "http://www.yetanotherurl.com" }; for (int i = 0; i < urls.Length; i++) { int j = i; actions.Add(() => Console.WriteLine(urls[j])); } |
| Résultat : IndexOutOfRangeException (Index was outside the bounds of the array |
Résultat : les liens du tableaux sont affichés |
- Les lambdas peuvent être nuire gravement à la santé … mentale des développeurs
Etrange non ? Décompilons le tout première exemple afin devoir ce qui est effectivement exécuté.
Note : Pour une raison inconnue, je n’ai pas réussi à obtenir ceci depuis Reflector. J’ai donc récupérer le code de l’article original.
[CompilerGenerated]
private sealed class <>c__DisplayClass2
{
// Fields
public int i;
// Methods
public void <Main>b__0()
{
Console.WriteLine(this.i);
}
}
[...]
var actions = new List<Action>();
<>c__DisplayClass2 localFrame = new <>c__DisplayClass2();
for (localFrame.i = 0; localFrame.i < 10; localFrame.i++)
{
actions.Add(localFrame.<Main>b__0);
}
foreach (var action in actions)
{
action();
}
Comme on peut le voir, le fait de créer une lambda en utilisant une variable extérieure à celle ci à entrainer la génération d’une classe (<>c__DisplayClass2") qui est utilisé pour stocker la valeur de cette variable (dans la varaible i) et une méthode (<Main>b__0) qui contient le code de la lambda. Si on regarde le code du premier for, on s’aperçoit que cette boucle incrémente la variable i de la classe DisplayClass2. Donc, à la fin de la première boucle, la classe DisplayClass2 contient une variable i = 10 et la liste actions contient une référence vers la méthode de cette classe. Ainsi lors de la boucle d’appel actions, on se retrouve a appeler le code Console.WriteLine(i) <=> Console.WriteLine(10) !!!!
Si on résonne de la même façon sur l’exemple 2, on obtient un appel Console.WriteLine(urls[4]) ==> Exception.
- Pourquoi l’utilisation d’une variable locale résout le problème
Si on regarde le code ci dessous, on s’aperçoit que le problème vient du fait que la classe DisplayClass2 est créé en dehors de la boucle for et que celle ci utilise la variable i comme compteur. Le fait d’utiliser une variable temporaire à l’intérieur de la boucle for, oblige le compilateur à créer plusieurs instance de DisplayClass (une par itération). On obtient ainsi quelque chose comme le code suivant.
for (int idx = 0; idx < 10; idx++)
{
<>c__DisplayClass2 localFrame = new <>c__DisplayClass2();
localFrame.i = idx;
actions.Add(localFrame.<Main>b__0);
}
Remarque : On pourrait penser que chaque instance est dispose lors de la sortie du scope. Cela n’’est pas vrai car la liste actiosn conserve une référence sur l’objet (en l’occurence sur une de ses méthodes) donc le garbage collector ne prend pas cet objet.
- Conclusion
Les lambdas sont aujourd’hui utilisé dans de nombreuses technologies .NET (LINQ,PFX…) et sont une bonne alternative aux délégués classiques. Toutefois, on peut voir que cela peut engendré une certaine confusion voire des bugs lorsqu’on les utilise.
Je vous mets le lien vers l’article dont je me suis fortement inspiré pour cet article : Lambdas – Know your closures
Astuces DotNet (Sébastien Courtois) 