NET 4.0 Tasks And Continuations

Ein wirklich cooles Feature im Namespace Task das in .NET 4.0 dazugekommen ist, ist das erstellen von Continuations.

Das bedeutet, das wenn man einen Task oder eine Reihe von Tasks ausführt hier die Möglichkeit existiert, Tasks erst nach vollendung des vorherigen Tasks auszuführen und diese Tasks sind sogar in der Lage, das Ergebnis ihrer Ausführung zu verwenden! Es bietet einen sehr einfachen Mechanismus der Koordinierung komplexer Verhaltensweisen von Threads.

Schauen wir uns das mal in einem Beispiel an: Statt des warten auf das Ergebnis mit direkten aufruf des Results, könnte man eine continuation verwenden, um den Wert, wenn die Aufgabe erledigt wurde, auf einem separaten Thread, in die Konsole zu schreiben. In diesem Fall würde nichts blockiert werden, die Anwendung wird weiter ausgeführt, also wenn die 3 Sekunden vorbei sind, würde die continuation ausgeführt und der Wert würde in die Konsole geschrieben werden. Der Code würde wie folgt aussehen:

Task.Factory.StartNew(() =>
{
    Thread.Sleep(3000);
    return "dummy value";
}).ContinueWith(task => Console.WriteLine(task.Result));

Man könnte es aber auch anders machen indem man eine weitere Zeile hinzufügt und hier die continuation anfügt:

var task = Task.Factory.StartNew(() =>
{
    Thread.Sleep(3000);
    return "dummy value";
});
task.ContinueWith(t => Console.WriteLine(t.Result));

Man kann auch mehr als nur eine continuation machen, man könnte sogar eine Kette von continuations machen:

Task.Factory.StartNew(() =>
{
    Thread.Sleep(3000);
    return "dummy value";
})
.ContinueWith(t => Console.WriteLine(t.Result))
.ContinueWith(t => Console.WriteLine("We are done!"));

Continuations bieten eine Menge an Möglichkeiten an, dass sie z.B nur ausgeführt werden soll, wenn ein Fehler auftritt, wenn Abbrüche auftreten, etc.

Man kann natürlich nicht nur einen Task nachdem ein anderer fertig ist fortsetzen, sondern auch einen Task ausführen sobald mehrere Tasks fertig sind:

var task1 = Task.Factory.StartNew(() =>
{
    Thread.Sleep(3000);
    return "dummy value 1";
});

var task2 = Task.Factory.StartNew(() =>
{
    Thread.Sleep(3000);
    return "dummy value 2";
});

var task3 = Task.Factory.StartNew(() =>
{
    Thread.Sleep(3000);
    return "dummy value 3";
});

Task.Factory.ContinueWhenAll(new[] { task1, task2, task3 }, tasks =>
{
    foreach (Task<string> task in tasks)
    {
        Console.WriteLine(task.Result);
    }
});

Somit, werden alle Tasks beendet und man kann auf jedes Ergebnis dieser Tasks zugreifen. Mit ContinueWhenAll wird hier wieder auch keinerlei ausführung geblockt.

Schlussbemerkung

Die Continuations sind nur ein Teilbereich von den Namensraum System.Threading.Tasks in .NET 4.0, aber ich hoffe, dass es ein wenig informativ war.