System.Threading.Tasks.Task-Klasse
Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.
Die Task Klasse stellt einen einzelnen Vorgang dar, der keinen Wert zurückgibt und in der Regel asynchron ausgeführt wird. TaskObjekte sind eine der zentralen Komponenten des aufgabenbasierten asynchronen Musters, das in .NET Framework 4 eingeführt wurde. Da die von einem Objekt ausgeführte Arbeit in der Task Regel asynchron in einem Threadpoolthread und nicht synchron im Standard Anwendungsthread ausgeführt wird, können Sie die Status Eigenschaft sowie die IsCanceledEigenschaften IsCompletedund IsFaulted Eigenschaften verwenden, um den Status einer Aufgabe zu bestimmen. In der Regel wird ein Lambda-Ausdruck verwendet, um die Auszuführende Arbeit anzugeben.
Für Vorgänge, die Werte zurückgeben, verwenden Sie die Task<TResult> Klasse.
Vorgangsinstanziierung
Im folgenden Beispiel werden vier Aufgaben erstellt und ausgeführt. Drei Aufgaben führen einen Action<T> Delegat mit dem Namen actionaus, der ein Argument vom Typ Objectakzeptiert. Eine vierte Aufgabe führt einen Lambda-Ausdruck (einen Action Delegaten) aus, der im Aufruf der Aufgabenerstellungsmethode inline definiert ist. Jede Aufgabe wird instanziiert und auf eine andere Weise ausgeführt:
Die Aufgabe
t1wird durch Aufrufen eines Task-Klassenkonstruktors instanziiert, wird jedoch erst gestartet, wenn Start() die Aufgabet2gestartet wurde.Die Aufgabe
t2wird instanziiert und in einem einzelnen Methodenaufruf gestartet, indem die TaskFactory.StartNew(Action<Object>, Object) Methode aufgerufen wird.Die Aufgabe
t3wird instanziiert und in einem einzelnen Methodenaufruf gestartet, indem die Run(Action) Methode aufgerufen wird.Die Aufgabe
t4wird synchron im Standard Thread ausgeführt, indem die RunSynchronously() Methode aufgerufen wird.
Da die Aufgabe t4 synchron ausgeführt wird, wird sie im Standard Anwendungsthread ausgeführt. Die re Standard ing-Aufgaben werden in der Regel in einem oder mehreren Threadpoolthreads asynchron ausgeführt.
using System;
using System.Threading;
using System.Threading.Tasks;
class Example1
{
static void Main()
{
Action<object> action = (object obj) =>
{
Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, obj,
Thread.CurrentThread.ManagedThreadId);
};
// Create a task but do not start it.
Task t1 = new Task(action, "alpha");
// Construct a started task
Task t2 = Task.Factory.StartNew(action, "beta");
// Block the main thread to demonstrate that t2 is executing
t2.Wait();
// Launch t1
t1.Start();
Console.WriteLine("t1 has been launched. (Main Thread={0})",
Thread.CurrentThread.ManagedThreadId);
// Wait for the task to finish.
t1.Wait();
// Construct a started task using Task.Run.
String taskData = "delta";
Task t3 = Task.Run(() =>
{
Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, taskData,
Thread.CurrentThread.ManagedThreadId);
});
// Wait for the task to finish.
t3.Wait();
// Construct an unstarted task
Task t4 = new Task(action, "gamma");
// Run it synchronously
t4.RunSynchronously();
// Although the task was run synchronously, it is a good practice
// to wait for it in the event exceptions were thrown by the task.
t4.Wait();
}
}
// The example displays output like the following:
// Task=1, obj=beta, Thread=3
// t1 has been launched. (Main Thread=1)
// Task=2, obj=alpha, Thread=4
// Task=3, obj=delta, Thread=3
// Task=4, obj=gamma, Thread=1
open System.Threading
open System.Threading.Tasks
let action =
fun (obj: obj) -> printfn $"Task={Task.CurrentId}, obj={obj}, Thread={Thread.CurrentThread.ManagedThreadId}"
// Create a task but do not start it.
let t1 = new Task(action, "alpha")
// Construct a started task
let t2 = Task.Factory.StartNew(action, "beta")
// Block the main thread to demonstrate that t2 is executing
t2.Wait()
// Launch t1
t1.Start()
printfn $"t1 has been launched. (Main Thread={Thread.CurrentThread.ManagedThreadId})"
// Wait for the task to finish.
t1.Wait()
// Construct a started task using Task.Run.
let taskData = "delta"
let t3 =
Task.Run(fun () -> printfn $"Task={Task.CurrentId}, obj={taskData}, Thread={Thread.CurrentThread.ManagedThreadId}")
// Wait for the task to finish.
t3.Wait()
// Construct an unstarted task
let t4 = new Task(action, "gamma")
// Run it synchronously
t4.RunSynchronously()
// Although the task was run synchronously, it is a good practice
// to wait for it in the event exceptions were thrown by the task.
t4.Wait()
// The example displays output like the following:
// Task=1, obj=beta, Thread=3
// t1 has been launched. (Main Thread=1)
// Task=2, obj=alpha, Thread=4
// Task=3, obj=delta, Thread=3
// Task=4, obj=gamma, Thread=1
Imports System.Threading
Imports System.Threading.Tasks
Module Example2
Public Sub Main()
Dim action As Action(Of Object) =
Sub(obj As Object)
Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, obj,
Thread.CurrentThread.ManagedThreadId)
End Sub
' Construct an unstarted task
Dim t1 As New Task(action, "alpha")
' Construct a started task
Dim t2 As Task = Task.Factory.StartNew(action, "beta")
' Block the main thread to demonstrate that t2 is executing
t2.Wait()
' Launch t1
t1.Start()
Console.WriteLine("t1 has been launched. (Main Thread={0})",
Thread.CurrentThread.ManagedThreadId)
' Wait for the task to finish.
t1.Wait()
' Construct a started task using Task.Run.
Dim taskData As String = "delta"
Dim t3 As Task = Task.Run(Sub()
Console.WriteLine("Task={0}, obj={1}, Thread={2}",
Task.CurrentId, taskData,
Thread.CurrentThread.ManagedThreadId)
End Sub)
' Wait for the task to finish.
t3.Wait()
' Construct an unstarted task
Dim t4 As New Task(action, "gamma")
' Run it synchronously
t4.RunSynchronously()
' Although the task was run synchronously, it is a good practice
' to wait for it in the event exceptions were thrown by the task.
t4.Wait()
End Sub
End Module
' The example displays output like the following:
' Task=1, obj=beta, Thread=3
' t1 has been launched. (Main Thread=1)
' Task=2, obj=alpha, Thread=3
' Task=3, obj=delta, Thread=3
' Task=4, obj=gamma, Thread=1
Erstellen und Ausführen einer Aufgabe
Sie können Instanzen auf unterschiedliche Weise erstellen Task . Der häufigste Ansatz besteht darin, die statische Run Methode aufzurufen. Die Run Methode bietet eine einfache Möglichkeit zum Starten einer Aufgabe mit Standardwerten und ohne zusätzliche Parameter. Im folgenden Beispiel wird die Run(Action) Methode verwendet, um eine Aufgabe zu starten, die schleift, und zeigt dann die Anzahl der Schleifeniterationen an:
using System;
using System.Threading.Tasks;
public class Example
{
public static async Task Main()
{
await Task.Run( () => {
// Just loop.
int ctr = 0;
for (ctr = 0; ctr <= 1000000; ctr++)
{}
Console.WriteLine("Finished {0} loop iterations",
ctr);
} );
}
}
// The example displays the following output:
// Finished 1000001 loop iterations
open System.Threading.Tasks
let main =
task {
do!
Task.Run(fun () ->
for i = 0 to 1000000 do
printfn $"Finished {i} loop iterations")
}
main.Wait()
// The example displays the following output:
// Finished 1000001 loop iterations
Imports System.Threading.Tasks
Module Example1
Public Sub Main()
Dim t As Task = Task.Run(Sub()
' Just loop.
Dim ctr As Integer = 0
For ctr = 0 To 1000000
Next
Console.WriteLine("Finished {0} loop iterations",
ctr)
End Sub)
t.Wait()
End Sub
End Module
' The example displays the following output:
' Finished 1000001 loop iterations
Eine Alternative ist die statische TaskFactory.StartNew Methode. Die Task.Factory Eigenschaft gibt ein TaskFactory Objekt zurück. Mit Überladungen der TaskFactory.StartNew Methode können Sie Parameter angeben, die an die Vorgangserstellungsoptionen und einen Aufgabenplaner übergeben werden sollen. Im folgenden Beispiel wird die TaskFactory.StartNew Methode verwendet, um eine Aufgabe zu starten. Sie entspricht funktional dem Code im vorherigen Beispiel.
using System;
using System.Threading.Tasks;
public class Example2
{
public static void Main()
{
Task t = Task.Factory.StartNew(() =>
{
// Just loop.
int ctr = 0;
for (ctr = 0; ctr <= 1000000; ctr++)
{ }
Console.WriteLine("Finished {0} loop iterations",
ctr);
});
t.Wait();
}
}
// The example displays the following output:
// Finished 1000001 loop iterations
open System.Threading.Tasks
let t =
Task.Factory.StartNew(fun () ->
// Just loop.
for i = 0 to 1000000 do
printfn $"Finished {i} loop iterations")
t.Wait()
// The example displays the following output:
// Finished 1000001 loop iterations
Imports System.Threading.Tasks
Module Example3
Public Sub Main()
Dim t As Task = Task.Factory.StartNew(Sub()
' Just loop.
Dim ctr As Integer = 0
For ctr = 0 To 1000000
Next
Console.WriteLine("Finished {0} loop iterations",
ctr)
End Sub)
t.Wait()
End Sub
End Module
' The example displays the following output:
' Finished 1000001 loop iterations
Ausführlichere Beispiele finden Sie unter Aufgabenbasierte asynchrone Programmierung.
Trennen der Aufgabenerstellung und -ausführung
Die Task Klasse stellt auch Konstruktoren bereit, die die Aufgabe initialisieren, aber nicht für die Ausführung planen. Aus Leistungsgründen ist die Methode TaskFactory.StartNew der Task.Run bevorzugte Mechanismus zum Erstellen und Planen von Rechenvorgängen, aber für Szenarien, in denen Erstellung und Planung getrennt sein müssen, können Sie die Konstruktoren verwenden und dann die Task.Start Methode aufrufen, um den Vorgang für die Ausführung zu einem späteren Zeitpunkt zu planen.
Warten, bis eine Aufgabe abgeschlossen ist
Da Aufgaben in der Regel asynchron in einem Threadpoolthread ausgeführt werden, wird der Thread, der die Aufgabe erstellt und startet, fortgesetzt, sobald die Aufgabe instanziiert wurde. In einigen Fällen kann die App beendet werden, wenn der aufrufende Thread der Standard Anwendungsthread ist, bevor die Aufgabe tatsächlich ausgeführt wird. In anderen Fällen muss die Logik Ihrer Anwendung die Ausführung des aufrufenden Threads nur fortsetzen, wenn eine oder mehrere Aufgaben die Ausführung abgeschlossen haben. Sie können die Ausführung des aufrufenden Threads und die asynchronen Aufgaben synchronisieren, die gestartet werden, indem Sie eine Wait Methode aufrufen, um auf eine oder mehrere Aufgaben zu warten, bis eine oder mehrere Aufgaben abgeschlossen sind.
Um auf den Abschluss einer einzelnen Aufgabe zu warten, können Sie dessen Task.Wait Methode aufrufen. Ein Aufruf der Wait Methode blockiert den aufrufenden Thread, bis die einzelne Klasseninstanz die Ausführung abgeschlossen hat.
Im folgenden Beispiel wird die parameterlose Wait() Methode aufgerufen, um bedingungslos zu warten, bis eine Aufgabe abgeschlossen ist. Der Vorgang simuliert die Arbeit, indem die Methode für den Thread.Sleep Ruhezustand für zwei Sekunden aufgerufen wird.
using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static Random rand = new Random();
static void Main()
{
// Wait on a single task with no timeout specified.
Task taskA = Task.Run( () => Thread.Sleep(2000));
Console.WriteLine("taskA Status: {0}", taskA.Status);
try {
taskA.Wait();
Console.WriteLine("taskA Status: {0}", taskA.Status);
}
catch (AggregateException) {
Console.WriteLine("Exception in taskA.");
}
}
}
// The example displays output like the following:
// taskA Status: WaitingToRun
// taskA Status: RanToCompletion
open System
open System.Threading
open System.Threading.Tasks
let rand = Random()
// Wait on a single task with no timeout specified.
let taskA = Task.Run(fun () -> Thread.Sleep 2000)
printfn $"taskA Status: {taskA.Status}"
try
taskA.Wait()
printfn $"taskA Status: {taskA.Status}"
with :? AggregateException ->
printfn "Exception in taskA."
// The example displays output like the following:
// taskA Status: WaitingToRun
// taskA Status: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks
Module Example4
Public Sub Main()
' Wait on a single task with no timeout specified.
Dim taskA = Task.Run(Sub() Thread.Sleep(2000))
Console.WriteLine("taskA Status: {0}", taskA.Status)
Try
taskA.Wait()
Console.WriteLine("taskA Status: {0}", taskA.Status)
Catch e As AggregateException
Console.WriteLine("Exception in taskA.")
End Try
End Sub
End Module
' The example displays output like the following:
' taskA Status: WaitingToRun
' taskA Status: RanToCompletion
Sie können auch bedingt warten, bis eine Aufgabe abgeschlossen ist. Die Wait(Int32) Methoden Wait(TimeSpan) blockieren den aufrufenden Thread, bis der Vorgang abgeschlossen ist oder ein Timeoutintervall verstrichen ist, je nachdem, was zuerst eintritt. Da im folgenden Beispiel eine Aufgabe gestartet wird, die zwei Sekunden lang in den Ruhezustand wechselt, aber einen Ein-Sekunden-Timeoutwert definiert, wird der aufrufende Thread blockiert, bis das Timeout abläuft und bevor die Ausführung der Aufgabe abgeschlossen ist.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Example5
{
public static void Main()
{
// Wait on a single task with a timeout specified.
Task taskA = Task.Run(() => Thread.Sleep(2000));
try
{
taskA.Wait(1000); // Wait for 1 second.
bool completed = taskA.IsCompleted;
Console.WriteLine("Task A completed: {0}, Status: {1}",
completed, taskA.Status);
if (!completed)
Console.WriteLine("Timed out before task A completed.");
}
catch (AggregateException)
{
Console.WriteLine("Exception in taskA.");
}
}
}
// The example displays output like the following:
// Task A completed: False, Status: Running
// Timed out before task A completed.
open System
open System.Threading
open System.Threading.Tasks
// Wait on a single task with a timeout specified.
let taskA = Task.Run(fun () -> Thread.Sleep 2000)
try
taskA.Wait 1000 |> ignore // Wait for 1 second.
let completed = taskA.IsCompleted
printfn $"Task A completed: {completed}, Status: {taskA.Status}"
if not completed then
printfn "Timed out before task A completed."
with :? AggregateException ->
printfn "Exception in taskA."
// The example displays output like the following:
// Task A completed: False, Status: Running
// Timed out before task A completed.
Imports System.Threading
Imports System.Threading.Tasks
Module Example5
Public Sub Main()
' Wait on a single task with a timeout specified.
Dim taskA As Task = Task.Run(Sub() Thread.Sleep(2000))
Try
taskA.Wait(1000) ' Wait for 1 second.
Dim completed As Boolean = taskA.IsCompleted
Console.WriteLine("Task.Completed: {0}, Status: {1}",
completed, taskA.Status)
If Not completed Then
Console.WriteLine("Timed out before task A completed.")
End If
Catch e As AggregateException
Console.WriteLine("Exception in taskA.")
End Try
End Sub
End Module
' The example displays the following output:
' Task A completed: False, Status: Running
' Timed out before task A completed.
Sie können auch ein Abbruchtoken bereitstellen, indem Sie die Wait(CancellationToken) Methoden aufrufen Wait(Int32, CancellationToken) . Wenn die Eigenschaft des IsCancellationRequested Tokens während true der Ausführung der Wait Methode erfolgt oder wirdtrue, löst die Methode eine OperationCanceledException.
In einigen Fällen möchten Sie möglicherweise auf den ersten einer Reihe von Aufgaben warten, die ausgeführt werden, aber nicht wichtig ist, welche Aufgabe es ist. Zu diesem Zweck können Sie eine der Überladungen der Task.WaitAny Methode aufrufen. Im folgenden Beispiel werden drei Aufgaben erstellt, die jeweils für ein Intervall schlafen, das durch einen Zufallszahlengenerator bestimmt wird. Die WaitAny(Task[]) Methode wartet auf den Abschluss der ersten Aufgabe. Im Beispiel werden dann Informationen zum Status aller drei Vorgänge angezeigt.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Example4
{
public static void Main()
{
var tasks = new Task[3];
var rnd = new Random();
for (int ctr = 0; ctr <= 2; ctr++)
tasks[ctr] = Task.Run(() => Thread.Sleep(rnd.Next(500, 3000)));
try
{
int index = Task.WaitAny(tasks);
Console.WriteLine("Task #{0} completed first.\n", tasks[index].Id);
Console.WriteLine("Status of all tasks:");
foreach (var t in tasks)
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status);
}
catch (AggregateException)
{
Console.WriteLine("An exception occurred.");
}
}
}
// The example displays output like the following:
// Task #1 completed first.
//
// Status of all tasks:
// Task #3: Running
// Task #1: RanToCompletion
// Task #4: Running
open System
open System.Threading
open System.Threading.Tasks
let rnd = new Random()
let tasks =
[| for _ = 0 to 2 do
Task.Run(fun () -> rnd.Next(500, 3000) |> Thread.Sleep) |]
try
let index = Task.WaitAny tasks
printfn $"Task #{tasks[index].Id} completed first.\n"
printfn "Status of all tasks:"
for t in tasks do
printfn $" Task #{t.Id}: {t.Status}"
with :? AggregateException ->
printfn "An exception occurred."
// The example displays output like the following:
// Task #1 completed first.
//
// Status of all tasks:
// Task #3: Running
// Task #1: RanToCompletion
// Task #4: Running
Imports System.Threading
Module Example8
Public Sub Main()
Dim tasks(2) As Task
Dim rnd As New Random()
For ctr As Integer = 0 To 2
tasks(ctr) = Task.Run(Sub() Thread.Sleep(rnd.Next(500, 3000)))
Next
Try
Dim index As Integer = Task.WaitAny(tasks)
Console.WriteLine("Task #{0} completed first.", tasks(index).Id)
Console.WriteLine()
Console.WriteLine("Status of all tasks:")
For Each t In tasks
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status)
Next
Catch e As AggregateException
Console.WriteLine("An exception occurred.")
End Try
End Sub
End Module
' The example displays output like the following:
' Task #1 completed first.
'
' Status of all tasks:
' Task #3: Running
' Task #1: RanToCompletion
' Task #4: Running
Sie können auch warten, bis eine Reihe von Aufgaben abgeschlossen ist, indem Sie die WaitAll Methode aufrufen. Das folgende Beispiel erstellt zehn Aufgaben, wartet auf den Abschluss aller zehn Aufgaben und zeigt dann den Status an.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Example3
{
public static void Main()
{
// Wait for all tasks to complete.
Task[] tasks = new Task[10];
for (int i = 0; i < 10; i++)
{
tasks[i] = Task.Run(() => Thread.Sleep(2000));
}
try
{
Task.WaitAll(tasks);
}
catch (AggregateException ae)
{
Console.WriteLine("One or more exceptions occurred: ");
foreach (var ex in ae.Flatten().InnerExceptions)
Console.WriteLine(" {0}", ex.Message);
}
Console.WriteLine("Status of completed tasks:");
foreach (var t in tasks)
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status);
}
}
// The example displays the following output:
// Status of completed tasks:
// Task #2: RanToCompletion
// Task #1: RanToCompletion
// Task #3: RanToCompletion
// Task #4: RanToCompletion
// Task #6: RanToCompletion
// Task #5: RanToCompletion
// Task #7: RanToCompletion
// Task #8: RanToCompletion
// Task #9: RanToCompletion
// Task #10: RanToCompletion
open System
open System.Threading
open System.Threading.Tasks
// Wait for all tasks to complete.
let tasks =
[| for _ = 0 to 9 do
Task.Run(fun () -> Thread.Sleep 2000) |]
try
Task.WaitAll tasks
with :? AggregateException as ae ->
printfn "One or more exceptions occurred: "
for ex in ae.Flatten().InnerExceptions do
printfn $" {ex.Message}"
printfn "Status of completed tasks:"
for t in tasks do
printfn $" Task #{t.Id}: {t.Status}"
// The example displays the following output:
// Status of completed tasks:
// Task #2: RanToCompletion
// Task #1: RanToCompletion
// Task #3: RanToCompletion
// Task #4: RanToCompletion
// Task #6: RanToCompletion
// Task #5: RanToCompletion
// Task #7: RanToCompletion
// Task #8: RanToCompletion
// Task #9: RanToCompletion
// Task #10: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks
Module Example6
Public Sub Main()
' Wait for all tasks to complete.
Dim tasks(9) As Task
For i As Integer = 0 To 9
tasks(i) = Task.Run(Sub() Thread.Sleep(2000))
Next
Try
Task.WaitAll(tasks)
Catch ae As AggregateException
Console.WriteLine("One or more exceptions occurred: ")
For Each ex In ae.Flatten().InnerExceptions
Console.WriteLine(" {0}", ex.Message)
Next
End Try
Console.WriteLine("Status of completed tasks:")
For Each t In tasks
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status)
Next
End Sub
End Module
' The example displays the following output:
' Status of completed tasks:
' Task #2: RanToCompletion
' Task #1: RanToCompletion
' Task #3: RanToCompletion
' Task #4: RanToCompletion
' Task #6: RanToCompletion
' Task #5: RanToCompletion
' Task #7: RanToCompletion
' Task #8: RanToCompletion
' Task #9: RanToCompletion
' Task #10: RanToCompletion
Beachten Sie, dass alle Ausnahmen, die in den ausgeführten Aufgaben ausgelöst werden, auf den Thread verteilt werden, der die Wait Methode aufruft, wenn Sie auf einen oder mehrere Aufgaben warten, wie im folgenden Beispiel gezeigt. Es startet 12 Vorgänge, von denen drei normal abgeschlossen sind und drei davon eine Ausnahme auslösen. Von der erneuten Standard sechs Vorgängen werden drei vor dem Start abgebrochen, und drei werden abgebrochen, während sie ausgeführt werden. Ausnahmen werden im WaitAll Methodenaufruf ausgelöst und von einem try/catch Block behandelt.
using System;
using System.Threading;
using System.Threading.Tasks;
public class Example6
{
public static void Main()
{
// Create a cancellation token and cancel it.
var source1 = new CancellationTokenSource();
var token1 = source1.Token;
source1.Cancel();
// Create a cancellation token for later cancellation.
var source2 = new CancellationTokenSource();
var token2 = source2.Token;
// Create a series of tasks that will complete, be cancelled,
// timeout, or throw an exception.
Task[] tasks = new Task[12];
for (int i = 0; i < 12; i++)
{
switch (i % 4)
{
// Task should run to completion.
case 0:
tasks[i] = Task.Run(() => Thread.Sleep(2000));
break;
// Task should be set to canceled state.
case 1:
tasks[i] = Task.Run(() => Thread.Sleep(2000),
token1);
break;
case 2:
// Task should throw an exception.
tasks[i] = Task.Run(() => { throw new NotSupportedException(); });
break;
case 3:
// Task should examine cancellation token.
tasks[i] = Task.Run(() =>
{
Thread.Sleep(2000);
if (token2.IsCancellationRequested)
token2.ThrowIfCancellationRequested();
Thread.Sleep(500);
}, token2);
break;
}
}
Thread.Sleep(250);
source2.Cancel();
try
{
Task.WaitAll(tasks);
}
catch (AggregateException ae)
{
Console.WriteLine("One or more exceptions occurred:");
foreach (var ex in ae.InnerExceptions)
Console.WriteLine(" {0}: {1}", ex.GetType().Name, ex.Message);
}
Console.WriteLine("\nStatus of tasks:");
foreach (var t in tasks)
{
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status);
if (t.Exception != null)
{
foreach (var ex in t.Exception.InnerExceptions)
Console.WriteLine(" {0}: {1}", ex.GetType().Name,
ex.Message);
}
}
}
}
// The example displays output like the following:
// One or more exceptions occurred:
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
//
// Status of tasks:
// Task #13: RanToCompletion
// Task #1: Canceled
// Task #3: Faulted
// NotSupportedException: Specified method is not supported.
// Task #8: Canceled
// Task #14: RanToCompletion
// Task #4: Canceled
// Task #6: Faulted
// NotSupportedException: Specified method is not supported.
// Task #7: Canceled
// Task #15: RanToCompletion
// Task #9: Canceled
// Task #11: Faulted
// NotSupportedException: Specified method is not supported.
// Task #12: Canceled
open System
open System.Threading
open System.Threading.Tasks
// Create a cancellation token and cancel it.
let source1 = new CancellationTokenSource()
let token1 = source1.Token
source1.Cancel()
// Create a cancellation token for later cancellation.
let source2 = new CancellationTokenSource()
let token2 = source2.Token
// Create a series of tasks that will complete, be cancelled,
// timeout, or throw an exception.
let tasks =
[| for i in 0..11 do
match i % 4 with
// Task should run to completion.
| 0 -> Task.Run(fun () -> Thread.Sleep 2000)
// Task should be set to canceled state.
| 1 -> Task.Run(fun () -> Thread.Sleep 2000, token1)
// Task should throw an exception.
| 2 -> Task.Run(fun () -> NotSupportedException())
// Task should examine cancellation token.
| _ ->
Task.Run(fun () ->
Thread.Sleep 2000
if token2.IsCancellationRequested then
token2.ThrowIfCancellationRequested()
Thread.Sleep 500, token2) |]
Thread.Sleep 250
source2.Cancel()
try
Task.WaitAll tasks
with :? AggregateException as ae ->
printfn "One or more exceptions occurred:"
for ex in ae.InnerExceptions do
printfn $" {ex.GetType().Name}: {ex.Message}"
printfn "\nStatus of tasks:"
for t in tasks do
printfn $" Task #{t.Id}: {t.Status}"
if isNull t.Exception |> not then
for ex in t.Exception.InnerExceptions do
printfn $" {ex.GetType().Name}: {ex.Message}"
// The example displays output like the following:
// One or more exceptions occurred:
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
// TaskCanceledException: A task was canceled.
// NotSupportedException: Specified method is not supported.
// TaskCanceledException: A task was canceled.
//
// Status of tasks:
// Task #13: RanToCompletion
// Task #1: Canceled
// Task #3: Faulted
// NotSupportedException: Specified method is not supported.
// Task #8: Canceled
// Task #14: RanToCompletion
// Task #4: Canceled
// Task #6: Faulted
// NotSupportedException: Specified method is not supported.
// Task #7: Canceled
// Task #15: RanToCompletion
// Task #9: Canceled
// Task #11: Faulted
// NotSupportedException: Specified method is not supported.
// Task #12: Canceled
Imports System.Threading
Imports System.Threading.Tasks
Module Example7
Public Sub Main()
' Create a cancellation token and cancel it.
Dim source1 As New CancellationTokenSource()
Dim token1 As CancellationToken = source1.Token
source1.Cancel()
' Create a cancellation token for later cancellation.
Dim source2 As New CancellationTokenSource()
Dim token2 As CancellationToken = source2.Token
' Create a series of tasks that will complete, be cancelled,
' timeout, or throw an exception.
Dim tasks(11) As Task
For i As Integer = 0 To 11
Select Case i Mod 4
' Task should run to completion.
Case 0
tasks(i) = Task.Run(Sub() Thread.Sleep(2000))
' Task should be set to canceled state.
Case 1
tasks(i) = Task.Run(Sub() Thread.Sleep(2000), token1)
Case 2
' Task should throw an exception.
tasks(i) = Task.Run(Sub()
Throw New NotSupportedException()
End Sub)
Case 3
' Task should examine cancellation token.
tasks(i) = Task.Run(Sub()
Thread.Sleep(2000)
If token2.IsCancellationRequested Then
token2.ThrowIfCancellationRequested()
End If
Thread.Sleep(500)
End Sub, token2)
End Select
Next
Thread.Sleep(250)
source2.Cancel()
Try
Task.WaitAll(tasks)
Catch ae As AggregateException
Console.WriteLine("One or more exceptions occurred:")
For Each ex In ae.InnerExceptions
Console.WriteLine(" {0}: {1}", ex.GetType().Name, ex.Message)
Next
End Try
Console.WriteLine()
Console.WriteLine("Status of tasks:")
For Each t In tasks
Console.WriteLine(" Task #{0}: {1}", t.Id, t.Status)
If t.Exception IsNot Nothing Then
For Each ex In t.Exception.InnerExceptions
Console.WriteLine(" {0}: {1}", ex.GetType().Name,
ex.Message)
Next
End If
Next
End Sub
End Module
' The example displays output like the following:
' One or more exceptions occurred:
' TaskCanceledException: A task was canceled.
' NotSupportedException: Specified method is not supported.
' TaskCanceledException: A task was canceled.
' TaskCanceledException: A task was canceled.
' NotSupportedException: Specified method is not supported.
' TaskCanceledException: A task was canceled.
' TaskCanceledException: A task was canceled.
' NotSupportedException: Specified method is not supported.
' TaskCanceledException: A task was canceled.
'
' Status of tasks:
' Task #13: RanToCompletion
' Task #1: Canceled
' Task #3: Faulted
' NotSupportedException: Specified method is not supported.
' Task #8: Canceled
' Task #14: RanToCompletion
' Task #4: Canceled
' Task #6: Faulted
' NotSupportedException: Specified method is not supported.
' Task #7: Canceled
' Task #15: RanToCompletion
' Task #9: Canceled
' Task #11: Faulted
' NotSupportedException: Specified method is not supported.
' Task #12: Canceled
Weitere Informationen zur Ausnahmebehandlung in aufgabenbasierten asynchronen Vorgängen finden Sie unter "Ausnahmebehandlung".
Aufgaben und Kultur
Beginnend mit Desktop-Apps, die auf .NET Framework 4.6 abzielen, wird die Kultur des Threads, der eine Aufgabe erstellt und aufruft, Teil des Threadkontexts. Das heißt, unabhängig von der aktuellen Kultur des Threads, auf dem die Aufgabe ausgeführt wird, ist die aktuelle Kultur der Aufgabe die Kultur des aufrufenden Threads. Bei Apps, die auf .NET Framework-Versionen vor .NET Framework 4.6 abzielen, ist die Kultur der Aufgabe die Kultur des Threads, auf dem die Aufgabe ausgeführt wird. Weitere Informationen finden Sie im Abschnitt "Kultur und aufgabenbasierte asynchrone Vorgänge" im CultureInfo Thema.
Hinweis
Store-Apps folgen dem Windows-Runtime beim Festlegen und Abrufen der Standardkultur.
Für Debuggerentwickler
Für Entwickler, die benutzerdefinierte Debugger implementieren, können mehrere interne und private Aufgabenmitglieder nützlich sein (diese können sich von Release zu Release ändern). Das m_taskId Feld dient als Sicherungsspeicher für die Id Eigenschaft, der Zugriff auf dieses Feld direkt aus einem Debugger kann jedoch effizienter sein als der Zugriff auf denselben Wert über die Getter-Methode der Eigenschaft (der s_taskIdCounter Zähler wird verwendet, um die nächste verfügbare ID für einen Vorgang abzurufen). Ebenso speichert das m_stateFlags Feld Informationen über die aktuelle Lebenszyklusstufe des Vorgangs, informationen, auf die auch über die Status Eigenschaft zugegriffen werden kann. Das m_action Feld speichert einen Verweis auf den Delegat der Aufgabe, und das m_stateObject Feld speichert den asynchronen Zustand, der vom Entwickler an die Aufgabe übergeben wird. Schließlich dient die InternalWait Methode für Debugger, die Stapelframes analysieren, eine potenzielle Markierung für den Fall, dass eine Aufgabe einen Wartevorgang eingibt.
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für