Task Klasse

Definition

Namespace:

System.Threading.Tasks

Assembly:

System.Runtime.dll

Stellt einen asynchronen Vorgang dar.

public ref class Task : IAsyncResult, IDisposable

public class Task : IAsyncResult, IDisposable

type Task = class
    interface IAsyncResult
    interface IDisposable

Public Class Task
Implements IAsyncResult, IDisposable

Vererbung

Object

Task

Abgeleitet

System.Threading.Tasks.Task<TResult>

Implementiert

IAsyncResult IDisposable

Hinweise

Die Task -Klasse stellt einen einzelnen Vorgang dar, der keinen Wert zurückgibt und normalerweise asynchron ausgeführt wird. Task-Objekte sind eine der zentralen Komponenten des aufgabenbasierten asynchronen Musters, das erstmals im .NET Framework 4 eingeführt wurde. Da die von einem Task -Objekt ausgeführte Arbeit in der Regel asynchron in einem Threadpoolthread und nicht synchron im Standard Anwendungsthreads ausgeführt wird, können Sie die Status -Eigenschaft sowie die IsCanceledEigenschaften , IsCompletedund IsFaulted verwenden, um den Status einer Aufgabe zu bestimmen. In der Regel wird ein Lambdaausdruck verwendet, um die Arbeit anzugeben, die die Aufgabe ausführen soll.

Für Vorgänge, die Werte zurückgeben, verwenden Sie die Task<TResult> -Klasse.

Inhalt dieses Abschnitts:

AufgabeninstanziierungsbeispieleErstellen und Ausführen einer AufgabeTrennen von Aufgabenerstellung und -ausführungWarten auf mindestens eine Aufgabe zum Abschließenvon Aufgaben und KulturFür Debuggerentwickler

Vorgangsinstanziierung

Im folgenden Beispiel werden vier Tasks erstellt und ausgeführt. Drei Aufgaben führen einen Action<T> Delegaten namens aus action, der ein Argument vom Typ Objectakzeptiert. Ein vierter Task führt einen Lambdaausdruck (einen Delegaten) aus Action , der im Aufruf der Vorgangserstellungsmethode inline definiert ist. Jede Aufgabe wird instanziiert und auf eine andere Weise ausgeführt:

• Der Task t1 wird durch Aufrufen eines Task-Klassenkonstruktors instanziiert, aber erst nach dem Starten der Aufgabe t2 durch Aufrufen der -Start()Methode gestartet.

• Der Task t2 wird instanziiert und in einem einzelnen Methodenaufruf durch Aufrufen der TaskFactory.StartNew(Action<Object>, Object) -Methode gestartet.

• Der Task t3 wird instanziiert und in einem einzelnen Methodenaufruf durch Aufrufen der Run(Action) -Methode gestartet.

• Der Task t4 wird synchron im Standard Thread ausgeführt, indem die RunSynchronously() -Methode aufgerufen wird.

Da der Task t4 synchron ausgeführt wird, wird er im Standard-Anwendungsthread ausgeführt. Die verbleibenden Aufgaben werden in der Regel in einem oder mehreren Threadpoolthreads asynchron ausgeführt.

using System;
using System.Threading;
using System.Threading.Tasks;

class Example
{
    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 Example
    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

Task -Instanzen können auf verschiedene Arten erstellt werden. Der gängigste Ansatz, der ab dem .NET Framework 4.5 verfügbar ist, ist das Aufrufen der statischen Run Methode. Die Run -Methode bietet eine einfache Möglichkeit, eine Aufgabe mit Standardwerten und ohne zusätzliche Parameter zu starten. Im folgenden Beispiel wird die Run(Action) -Methode verwendet, um eine Aufgabe zu starten, die schleift und dann die Anzahl der Schleifeniterationen anzeigt:

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 Example
   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 und die häufigste Methode zum Starten einer Aufgabe in .NET Framework 4 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 Aufgabenerstellungsoptionen 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 Example
{
   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 Example
   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 von Aufgabenerstellung und -ausführung

Die Task -Klasse stellt auch Konstruktoren bereit, die den Task initialisieren, aber die Ausführung nicht planen. Aus Leistungsgründen ist die Task.Run -Methode oder TaskFactory.StartNew der bevorzugte Mechanismus zum Erstellen und Planen von Rechenaufgaben. In Szenarien, in denen Erstellung und Planung getrennt werden müssen, können Sie jedoch die Konstruktoren verwenden und dann die -Methode aufrufen, um die Task.Start Ausführung des Vorgangs zu einem späteren Zeitpunkt zu planen.

Warten auf den Abschluss einer oder mehrerer Aufgaben

Da Aufgaben in der Regel asynchron in einem Threadpoolthread ausgeführt werden, setzt der Thread, der die Aufgabe erstellt und startet, die Ausführung fort, sobald die Aufgabe instanziiert wurde. In einigen Fällen, wenn der aufrufende Thread der Standard Anwendungsthread ist, kann die App beendet werden, bevor die Ausführung der Aufgabe tatsächlich beginnt. In anderen Fällen erfordert die Logik Ihrer Anwendung möglicherweise, dass der aufrufende Thread die Ausführung nur dann fortsetzen muss, wenn mindestens eine Aufgabe ausgeführt wurde. Sie können die Ausführung des aufrufenden Threads und der von diesem gestarteten asynchronen Aufgaben synchronisieren, indem Sie eine Wait -Methode aufrufen, um auf den Abschluss einer oder mehrerer Aufgaben zu warten.

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 Ausführung der einzelnen Klasse instance abgeschlossen ist.

Im folgenden Beispiel wird die parameterlose Wait() Methode aufgerufen, um bedingungslos zu warten, bis eine Aufgabe abgeschlossen ist. Die Aufgabe simuliert die Arbeit, indem die -Methode für zwei Sekunden in den Thread.Sleep Standbymodus 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 Example
   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 und Wait(TimeSpan) blockieren den aufrufenden Thread, bis die Aufgabe 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 versetzt wird, aber einen Timeoutwert von einer Sekunde definiert, blockiert der aufrufende Thread, 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 Example
{
   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 Example
   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 und Wait(Int32, CancellationToken) aufrufen. Wenn die -Eigenschaft des IsCancellationRequested Tokens ist true oder wird true , während die Wait -Methode ausgeführt wird, löst die -Methode einen aus OperationCanceledException.

In einigen Fällen möchten Sie möglicherweise warten, bis der erste einer Reihe von ausgeführten Aufgaben abgeschlossen ist, aber es ist egal, um welche Aufgabe es sich handelt. Zu diesem Zweck können Sie eine der Überladungen der Task.WaitAny -Methode aufrufen. Im folgenden Beispiel werden drei Aufgaben erstellt, von denen jede für ein durch einen Zufallszahlengenerator festgelegtes Intervall in den Ruhezustand versetzt wird. Die WaitAny(Task[]) -Methode wartet, bis die erste Aufgabe abgeschlossen ist. Im Beispiel werden dann Informationen zur status aller drei Aufgaben angezeigt.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   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
Imports System.Threading.Tasks

Module Example
   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 alle Aufgaben abgeschlossen sind, indem Sie die WaitAll -Methode aufrufen. Im folgenden Beispiel werden zehn Aufgaben erstellt, gewartet, bis alle zehn abgeschlossen sind, und dann deren status angezeigt.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   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 Example
   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 beim Warten auf den Abschluss einer oder mehrerer Aufgaben alle in den ausgeführten Tasks ausgelösten Ausnahmen für den Thread weitergegeben werden, der die Wait -Methode aufruft, wie im folgenden Beispiel gezeigt. Er startet 12 Aufgaben, von denen drei normal abgeschlossen werden und drei von denen eine Ausnahme auslösen. Von den verbleibenden sechs Aufgaben werden drei abgebrochen, bevor sie beginnen, und drei werden während der Ausführung abgebrochen. 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 Example
{
   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 Example
   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
                                           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

Ab Desktop-Apps, die auf die .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, in dem die Aufgabe ausgeführt wird, ist die aktuelle Kultur der Aufgabe die Kultur des aufrufenden Threads. Für Apps, die Versionen der .NET Framework vor dem .NET Framework 4.6 als Ziel verwenden, ist die Kultur der Aufgabe die Kultur des Threads, in dem die Aufgabe ausgeführt wird. Weitere Informationen finden Sie im Abschnitt "Kultur und aufgabenbasierte asynchrone Vorgänge" im CultureInfo Thema.

Hinweis

Store-Apps befolgen die Windows-Runtime in der Einstellung und abrufen der Standardkultur.

Für Debuggerentwickler

Für Entwickler, die benutzerdefinierte Debugger implementieren, können mehrere interne und private Mitglieder der Aufgabe nützlich sein (diese können von Release zu Release geändert werden). Das m_taskId Feld dient als Sicherungsspeicher für die Id Eigenschaft. Der direkte Zugriff auf dieses Feld über einen Debugger kann jedoch effizienter sein als der Zugriff auf denselben Wert über die getter-Methode der Eigenschaft (der s_taskIdCounter Indikator wird verwendet, um die nächste verfügbare ID für eine Aufgabe abzurufen). Auf ähnliche Weise speichert das m_stateFlags Feld Informationen zur aktuellen Lebenszyklusphase der Aufgabe, 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. Für Debugger, die Stapelframes analysieren, dient die InternalWait -Methode schließlich einem potenziellen Marker, wenn ein Task in einen Wartevorgang eintritt.

Konstruktoren

Task(Action)	Initialisiert eine neue Task mit der angegebenen Aktion.
Task(Action, CancellationToken)	Initialisiert eine neue Task mit den angegebenen Werten für Aktion und CancellationToken.
Task(Action, CancellationToken, TaskCreationOptions)	Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.
Task(Action, TaskCreationOptions)	Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.
Task(Action<Object>, Object)	Initialisiert eine neue Task mit den angegebenen Werten für Aktion und Zustand.
Task(Action<Object>, Object, CancellationToken)	Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.
Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)	Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.
Task(Action<Object>, Object, TaskCreationOptions)	Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.

Eigenschaften

AsyncState	Ruft das beim Erstellen des Task angegebene Zustandsobjekt ab, oder NULL, wenn kein Zustandsobjekt angegeben wurde.
CompletedTask	Ruft eine Aufgabe ab, die bereits erfolgreich abgeschlossen wurde.
CreationOptions	Ruft die zum Erstellen dieser Aufgabe verwendeten TaskCreationOptions ab.
CurrentId	Gibt die ID der momentan ausgeführten Task zurück.
Exception	Ruft die AggregateException ab, die die vorzeitige Beendigung der Task verursacht hat. Wenn der Task erfolgreich abgeschlossen wurde oder noch keine Ausnahmen ausgelöst wurden, wird null zurückgegeben.
Factory	Bietet Zugriff auf Factorymethoden zum Erstellen und Konfigurieren von Task- und Task<TResult>-Instanzen.
Id	Ruft eine ID für diese Task-Instanz ab.
IsCanceled	Ruft einen Wert ab, der angibt, ob diese Task-Instanz die Ausführung aufgrund eines Abbruchs abgeschlossen hat.
IsCompleted	Ruft einen Wert ab, der angibt, ob die Aufgabe abgeschlossen wurde.
IsCompletedSuccessfully	Ruft ab, ob der Task bis zum Abschluss ausgeführt wurde.
IsFaulted	Ruft einen Wert ab, der angibt, ob die Task aufgrund einer nicht behandelten Ausnahme abgeschlossen wurde.
Status	Ruft den TaskStatus dieser Aufgabe ab.

Methoden

ConfigureAwait(Boolean)	Konfiguriert einen Awaiter, der verwendet wird, um diese Task zu erwarten.
ContinueWith(Action<Task,Object>, Object)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist.
ContinueWith(Action<Task,Object>, Object, CancellationToken)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.
ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt und verwendet einen angegebenen Zeitplan.
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt.
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung verwendet einen angegebenen Zeitplan.
ContinueWith(Action<Task>)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.
ContinueWith(Action<Task>, CancellationToken)	Erstellt eine Fortsetzung, die ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird. Die Fortsetzung empfängt ein Abbruchtoken und verwendet einen angegebenen Zeitplan.
ContinueWith(Action<Task>, TaskContinuationOptions)	Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird.
ContinueWith(Action<Task>, TaskScheduler)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung verwendet einen angegebenen Zeitplan.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken und verwendet den angegebenen Zeitplan.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen und verwendet einen angegebenen Zeitplan.
ContinueWith<TResult>(Func<Task,TResult>)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde, und gibt einen Wert zurück.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung empfängt ein Abbruchtoken.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück. An die Fortsetzung wird ein Abbruchtoken übergeben, und sie verwendet einen angegebenen Zeitplan.
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück.
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung verwendet einen angegebenen Zeitplan.
Delay(Int32)	Erstellt eine Aufgabe, die nach Ablauf einer festgelegten Anzahl an Millisekunden abgeschlossen wird.
Delay(Int32, CancellationToken)	Erstellt eine stornierbare Aufgabe, die nach Ablauf einer festgelegten Anzahl an Millisekunden abgeschlossen wird.
Delay(TimeSpan)	Erstellt eine Aufgabe, die nach Ablauf einer festgelegten Zeitspanne abgeschlossen wird.
Delay(TimeSpan, CancellationToken)	Erstellt eine abzubrechende Aufgabe, die nach Ablauf einer festgelegten Zeitspanne abgeschlossen wird.
Dispose()	Gibt alle von der aktuellen Instanz der Task-Klasse verwendeten Ressourcen frei.
Dispose(Boolean)	Verwirft den Task und gibt somit alle von ihm verwendeten nicht verwalteten Ressourcen frei.
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
FromCanceled(CancellationToken)	Erstellt einen durch Abbruch abgeschlossenen Task mit einem angegebenen Abbruchtoken.
FromCanceled<TResult>(CancellationToken)	Erstellt einen durch Abbruch abgeschlossenen Task<TResult> mit einem angegebenen Abbruchtoken.
FromException(Exception)	Erstellt einen durch eine angegebene Ausnahme abgeschlossenen Task.
FromException<TResult>(Exception)	Erstellt einen durch eine angegebene Ausnahme abgeschlossenen Task<TResult>.
FromResult<TResult>(TResult)	Erstellt ein Task<TResult>, die erfolgreich mit dem angegebenen Ergebnis abgeschlossen ist.
GetAwaiter()	Ruft einen Awaiter ab, der verwendet wird, um diese Task zu erwarten.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
Run(Action)	Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschlange hinzu und gibt ein Task-Objekt zurück, das diese Aufgabe darstellt.
Run(Action, CancellationToken)	Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschlange hinzu und gibt ein Task-Objekt zurück, das diese Aufgabe darstellt. Ein Abbruchtoken ermöglicht den Abbruch der Arbeit, wenn diese noch nicht begonnen wurde.
Run(Func<Task>)	Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschleife hinzu und gibt einen Proxy für die Aufgabe zurück, die von function zurückgegeben wird.
Run(Func<Task>, CancellationToken)	Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschleife hinzu und gibt einen Proxy für die Aufgabe zurück, die von function zurückgegeben wird. Ein Abbruchtoken ermöglicht den Abbruch der Arbeit, wenn diese noch nicht begonnen wurde.
Run<TResult>(Func<Task<TResult>>)	Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschleife hinzu und gibt einen Proxy für die Task(TResult) zurück, die von function zurückgegeben wird. Ein Abbruchtoken ermöglicht den Abbruch der Arbeit, wenn diese noch nicht begonnen wurde.
Run<TResult>(Func<Task<TResult>>, CancellationToken)	Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschleife hinzu und gibt einen Proxy für die Task(TResult) zurück, die von function zurückgegeben wird.
Run<TResult>(Func<TResult>)	Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschlange hinzu und gibt ein Task<TResult>-Objekt zurück, das diese Aufgabe darstellt. Ein Abbruchtoken ermöglicht den Abbruch der Arbeit, wenn diese noch nicht begonnen wurde.
Run<TResult>(Func<TResult>, CancellationToken)	Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschlange hinzu und gibt ein Task(TResult)-Objekt zurück, das diese Aufgabe darstellt.
RunSynchronously()	Führt den Task synchron mit dem aktuellen TaskScheduler aus.
RunSynchronously(TaskScheduler)	Führt die Task synchron mit dem bereitgestellten TaskScheduler aus.
Start()	Startet die Task und plant ihre Ausführung mit dem aktuellen TaskScheduler.
Start(TaskScheduler)	Startet die Task und plant ihre Ausführung mit dem angegebenen TaskScheduler.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
Wait()	Wartet, bis der Task die Ausführung abschließt.
Wait(CancellationToken)	Wartet, bis der Task die Ausführung abschließt. Der Wartevorgang wird beendet, wenn ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen ist.
Wait(Int32)	Wartet darauf, dass die Task innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt wird.
Wait(Int32, CancellationToken)	Wartet, bis der Task die Ausführung abschließt. Der Wartevorgang wird beendet, wenn ein Timeoutintervall abläuft oder ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen ist.
Wait(TimeSpan)	Wartet darauf, dass die Task innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt wird.
Wait(TimeSpan, CancellationToken)	Wartet, bis der Task die Ausführung abschließt.
WaitAll(Task[])	Wartet, bis alle bereitgestellten Task-Objekte die Ausführung abschließen.
WaitAll(Task[], CancellationToken)	Wartet, bis alle bereitgestellten Task-Objekte die Ausführung abschließen oder bis der Wartevorgang abgebrochen wird.
WaitAll(Task[], Int32)	Wartet darauf, dass alle bereitgestellten Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt werden.
WaitAll(Task[], Int32, CancellationToken)	Wartet darauf, dass alle bereitgestellten Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden oder vollständig ausgeführt werden, oder bis zum Abbruch des Wartevorgangs.
WaitAll(Task[], TimeSpan)	Wartet darauf, dass alle bereitgestellten Task-Objekte, die abgebrochen werden können, innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt werden.
WaitAny(Task[])	Wartet, bis eines der bereitgestellten Task-Objekte die Ausführung abschließt.
WaitAny(Task[], CancellationToken)	Wartet, bis bereitgestellte Task-Objekte die Ausführung abschließen oder bis der Wartevorgang abgebrochen wird.
WaitAny(Task[], Int32)	Wartet darauf, dass bereitgestellte Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt werden.
WaitAny(Task[], Int32, CancellationToken)	Wartet darauf, dass bereitgestellte Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden oder vollständig ausgeführt werden, oder bis ein Abbruchtoken abgebrochen wird.
WaitAny(Task[], TimeSpan)	Wartet darauf, dass bereitgestellte Task-Objekte, die abgebrochen werden können, innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt werden.
WaitAsync(CancellationToken)	Ruft eine Task ab, die abgeschlossen wird, wenn dies Task abgeschlossen ist oder wenn der angegebene CancellationToken Abbruch angefordert wurde.
WaitAsync(TimeSpan)	Ruft eine Task ab, die abgeschlossen wird, wenn dies Task abgeschlossen ist oder das angegebene Timeout abläuft.
WaitAsync(TimeSpan, CancellationToken)	Ruft eine Task ab, die abgeschlossen wird, wenn dies Task abgeschlossen ist, wenn das angegebene Timeout abläuft oder wenn der angegebene CancellationToken Abbruch angefordert wurde.
WhenAll(IEnumerable<Task>)	Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einer aufzählbaren Sammlung abgeschlossen sind.
WhenAll(Task[])	Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einem Array abgeschlossen sind.
WhenAll<TResult>(IEnumerable<Task<TResult>>)	Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult>-Objekte in einer aufzählbaren Sammlung abgeschlossen sind.
WhenAll<TResult>(Task<TResult>[])	Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult>-Objekte in einem Array abgeschlossen sind.
WhenAny(IEnumerable<Task>)	Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist.
WhenAny(Task, Task)	Erstellt einen Task, der abgeschlossen wird, wenn einer der angegebenen Tasks abgeschlossen ist.
WhenAny(Task[])	Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist.
WhenAny<TResult>(IEnumerable<Task<TResult>>)	Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist.
WhenAny<TResult>(Task<TResult>, Task<TResult>)	Erstellt einen Task, der abgeschlossen wird, wenn einer der angegebenen Tasks abgeschlossen ist.
WhenAny<TResult>(Task<TResult>[])	Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist.
Yield()	Erstellt eine Awaitable-Aufgabe, die asynchron an den aktuellen Kontext liefert, wenn erwartet.

Explizite Schnittstellenimplementierungen

IAsyncResult.AsyncWaitHandle	Ruft ein WaitHandle ab, das verwendet werden kann, um auf den Abschluss der Aufgabe zu warten.
IAsyncResult.CompletedSynchronously	Ruft einen Wert ab, der angibt, ob der Vorgang synchron abgeschlossen wurde.

Erweiterungsmethoden

Threadsicherheit

Alle Member von Tasksind threadsicher Dispose()und können von mehreren Threads gleichzeitig verwendet werden.

Weitere Informationen

• Task<TResult>
• Task Parallel Library (TPL)
• Aufgabenbasiertes asynchrones Muster (TAP) in .NET: Einführung und Übersicht
• Aufgabenbasierte asynchrone Programmierung
• Beispiele für die parallele Programmierung mit .NET Core und .NET Standard