Perché C# non conserva il contesto per le chiamate anonime dei delegati?

Question

Ho il seguente metodo:

static Random rr = new Random(); 
static void DoAction(Action a) 
{ 
    ThreadPool.QueueUserWorkItem(par => 
    { 
     Thread.Sleep(rr.Next(200)); 
     a.Invoke(); 
    }); 
} 

ora chiamare questo in un ciclo come questo:

for (int i = 0; i < 10; i++) 
{ 
    var x = i; 

    DoAction(() => 
    { 
     Console.WriteLine(i); // scenario 1 
     //Console.WriteLine(x); // scenario 2 
    }); 
} 

in scenario 1 dell'output sono: 10 10 10 10 ... 10
nello scenario 2 l'uscita è: 2 6 5 8 4 ... 0 (permutazione casuale da 0 a 9)

Come si spiega? C# non dovrebbe conservare le variabili (qui i) per la chiamata anonima del delegato?

Answer 1

Il problema qui è che c'è una variabile i e dieci istanze/copie di x. Ogni lambda riceve un riferimento alla singola variabile i e una delle istanze di x. Ogni x viene scritto solo una volta e quindi ogni lambda vede l'unico valore che è stato scritto nel valore a cui fa riferimento.

La variabile i viene scritto fino a raggiungere 10. Nessuno dei lambda eseguito fino a quando il ciclo viene completata in modo che tutti vedono il valore finale di i quali è 10

Trovo questo esempio è un po 'più chiara se si riscriverlo come segue

int i = 0; // Single i for every iteration of the loop 
while (i < 10) { 
    int x = i; // New x for every iteration of the loop 
    DoAction(() => { 
    Console.WriteLine(i); 
    Console.WriteLine(x); 
    }); 
    i++; 
}; 

Answer 2

Penso che si otterrà lo stesso risultato con Java o qualsiasi oggetto linguaggio orientato (non sono sicuro, ma qui sembra logico).

L'ambito di i è per l'intero ciclo e l'ambito di x è per ogni occorrenza.

Il resharper aiuta a individuare questo tipo di problema.

Answer 3

DoAction genera il thread e ritorna immediatamente. Quando il thread si risveglia dal suo sonno casuale, il ciclo sarà terminato e il valore di i sarà avanzato fino a 10. Il valore di x, d'altra parte, viene catturato e congelato prima della chiamata , quindi otterrete tutti i valori da 0 a 9 in ordine casuale, a seconda di quanto tempo ogni thread si addormenta in base al generatore di numeri casuali.