Discussion :

[StormimOn]

Bonjour,

Je rencontre un comportement que je ne comprends pas. C'est probablement tout bête, mais si quelqu'un peut m'expliquer le pourquoi du comment histoire que je me couche moins bête ce soir

Soit les classes Item et OtherItem

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Item
{
    public Action Action { get; set; }
}
 
class OtherItem
{
    public event EventHandler Click = delegate { };
 
    public void ClickRequested()
    {
        Click(this, EventArgs.Empty);
    }
}

et le code suivant

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
class Program
{
    static void Main(string[] args)
    {
        Item item1 = new Item { Action = delegate { Console.WriteLine("Item 1"); } };
        Item item2 = new Item { Action = delegate { Console.WriteLine("Item 2"); } };
        Item item3 = new Item { Action = delegate { Console.WriteLine("Item 3"); } };
 
        List<Item> items = new List<Item> { item1, item2, item3 };
        List<OtherItem> otherItems = new List<OtherItem>();
 
        foreach (Item item in items)
        {
            OtherItem otherItem = new OtherItem();
            otherItem.Click += delegate { item.Action(); };
            otherItems.Add(otherItem);
        }
 
        foreach (OtherItem otherItem in otherItems)
        {                
            otherItem.ClickRequested();
        }
 
        Console.ReadLine();
    }
}

Alors que je m'attends à avoir très logiquement en sortie

Item 1
Item 2
Item 3

le code précédent affiche en réalité

Item 3
Item 3
Item 3

Si je modifie légèrement la première boucle foreach en stockant dans une variable l'objet énuméré

Code :

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

1
2
3
4
5
6
7
foreach (Item item in items)
{
    Item i = item;
    OtherItem otherItem = new OtherItem();
    otherItem.Click += delegate { i.Action(); };
    otherItems.Add(otherItem);
}

Le comportement est alors celui attendu

Bref, je ne suis pas sûr de comprendre le pourquoi de la chose. Est-ce lié à la capture de variable de la méthode anonyme ? Bien que je ne vois pas pourquoi.

[tomlev]

Ah, voilà une question intéressante

Est-ce lié à la capture de variable de la méthode anonyme ?

Oui, c'est tout à fait ça. En fait, dans ton foreach, ce n'est pas la valeur de la variable item qui est capturée, mais la variable elle-même. Il y a une explication un peu plus complète sur le site de Jon Skeet.

Sinon, juste pour le fun, voilà une version un peu modifiée de ton code, utilisant les expressions Linq pour mieux comprendre ce qui se passe :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
            ...
 
            foreach (Item item in items)
            {
                OtherItem otherItem = new OtherItem();
                Expression<EventHandler> expr = (sender, e) => item.Action();
                Console.WriteLine(expr);
                otherItem.Click += expr.Compile();
                otherItems.Add(otherItem);
            }
 
            ...

Le résultat est le suivant :

(sender, e) => Invoke(value(ConsoleApplication1.Program+<>c__DisplayClassa).item.Action)
(sender, e) => Invoke(value(ConsoleApplication1.Program+<>c__DisplayClassa).item.Action)
(sender, e) => Invoke(value(ConsoleApplication1.Program+<>c__DisplayClassa).item.Action)
Item 3
Item 3
Item 3

On voit donc que l'expression ne prend pas directement la valeur de item, mais qu'elle y accède en tant que membre d'une classe générée par le compilateur (ConsoleApplication1.Program+<>c__DisplayClassa)

Juste pour info, voilà le code de cette classe générée :

Code :

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

1
2
3
4
5
6
7
8
9
[CompilerGenerated]
private sealed class <>c__DisplayClassa
{
    // Fields
    public Program.Item item;
 
    // Methods
    public <>c__DisplayClassa();
}

[StormimOn]

Ok je comprends mieux. Je connaissais le principe, mais pas la distinction sur le fait qu'une variable pouvait être commune au différentes méthodes anonymes en fonction de l'endroit où elle est déclarée.

Merci