Verwendung anonymer Methoden innerhalb einer verzögerten Aufgabe innerhalb einer Schleife

Question

ich folgendes haben -

for (int i = 0; i < N; ++i) 
{ 
    var firstTask = DoSomething(...); 

    var task = anotherTask.ContinueWith(
     (t) => ProcessResult(i, t.Result)); 
} 

Problem ist, dass der Wert von i in ProcessResult vergangen scheint, den Wert zu sein, wenn es beginnt, den Wert von die Iteration, wenn es erstellt wird.

Was ist der beste Schutz dagegen?

Answer 1

Sie müssen den Wert i in einer eigenen Variablen erfassen.

for (int i = 0; i < N; ++i) 
{ 
    var count = i; 

    var firstTask = DoSomething(...); 

    var task = anotherTask.ContinueWith(
     (t) => ProcessResult(count, t.Result)); 
} 

Beispiel:

for (int i = 0; i < 5; ++i) 
{ 
    var a = i; 
    var task = Task.Delay(0).ContinueWith((t) => a.Dump()); 
} 

Dies gibt so etwas wie:

0 
2 
1 
4 
3 

Aber:

for (int i = 0; i < 5; ++i) 
{ 
    var task = Task.Delay(0).ContinueWith((t) => i.Dump()); 
} 

Ausgänge:

5 
5 
5 
5 
5 

Answer 2

Sie müssen eine temporäre Variable innerhalb der Schleife erstellen; In Ihrem aktuellen Code erfassen Sie die Variable i, nicht den Wert, was bedeutet, dass, wenn die Fortsetzungsaufgaben schließlich ausgeführt werden, die Schleife bereits abgeschlossen ist und iN-1 ist.

for (int i = ...) 
{ 
    var temp = i; 
    var task = anotherTask.ContinueWith(t => ProcessResult(temp, t.Resume)); 
} 

Answer 3

Ein Lambda, das eine äußere Variable verwendet, erfasst tatsächlich die Variable, nicht den darin gespeicherten Wert. Das bedeutet, dass mit fortschreitender Schleife auch der Wert geändert wird, den Sie aus der erfassten Variablen lesen würden.

Sie können dies beheben, indem Sie eine temporäre Variable in der Schleife verwenden. Ihr Code wäre viel sauberer sein aber wenn Sie async/await statt ContinueWith und Lambda-Ausdrücke verwendet werden, zB:

for (int i=0;i<N;i++) 
{ 
    //... 
    var result=await thatOtherAsyncMethod(...); 
    ProcessResult(i, result)); 
} 

In der Regel können Sie Capture-Probleme vermeiden, durch Kopieren des Schleifenvariable in eine Variable innerhalb der Schleife des Oszilloskops definiert.

Dies behebt das Problem, da die temporäre Variable nur innerhalb des Körpers der Schleife existiert. Die Lambda ist auch innerhalb der Schleife des Körpers erstellt und erfasst eine lokale, unveränderliche Variable:

for (int i=0;i<N;i++) 
{ 
    var temp=i; 
    var myLambda = new Action(()=>MyMethod(temp)); 

    //This runs with the local copy, not i 
    myLambda(); 
} 

Ein noch besserer Weg aber ist zu vermeiden erfasst und die Schleife Wert als Zustandsparameter zu ContinueWith passieren, zB:

for (int i = 0; i < N; ++i) 
{ 
    //... 
    var task = anotherTask.ContinueWith(
           (t,state) => ProcessResult((int)state, t.Result), 
           i); 
    //... 
}