Task Task Task Task Class

Definition

Stellt einen asynchronen Vorgang dar. Represents an asynchronous operation.

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
TaskTaskTaskTask
Abgeleitet
Implementiert

Hinweise

Die Task -Klasse stellt ein einzelnen Vorgang, die keinen Wert und die in der Regel zurückgibt wird asynchron ausgeführt.The Task class represents a single operation that does not return a value and that usually executes asynchronously. Task Objekte sind eine der zentralen Komponenten von der aufgabenbasierte asynchrone Muster in .NET Framework 4 eingeführt wurden.Task objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. Da die Arbeit, indem geleistet eine Task Objekt in der Regel führt asynchron auf einem Threadpoolthread anstatt synchron auf dem Hauptanwendungsthread, Sie verwenden können der Status -Eigenschaft, als auch die IsCanceled, IsCompleted, und IsFaulted Eigenschaften, um den Status eines Vorgangs zu bestimmen.Because the work performed by a Task object typically executes asynchronously on a thread pool thread rather than synchronously on the main application thread, you can use the Status property, as well as the IsCanceled, IsCompleted, and IsFaulted properties, to determine the state of a task. In den meisten Fällen wird ein Lambda-Ausdruck verwendet, an die Arbeit, die die Aufgabe auszuführen.Most commonly, a lambda expression is used to specify the work that the task is to perform.

Für Vorgänge, die Werte zurückgeben, verwenden Sie die Task<TResult> Klasse.For operations that return values, you use the Task<TResult> class.

In diesem AbschnittIn this section:

Instanziierung-Beispiele Task instantiation examples
Erstellen und Ausführen einer Aufgabe Creating and executing a task
Trennung von Erstellung und Ausführung Separating task creation and execution
Warten auf eine oder mehrere Aufgaben ausführen Waiting for one or more tasks to complete
Aufgaben und Kultur Tasks and culture
Für DebuggerentwicklerFor debugger developers

Task-InstanziierungTask instantiation

Das folgende Beispiel erstellt und vier Aufgaben ausführt.The following example creates and executes four tasks. Führen Sie drei Aufgaben ein Action<T> Delegat mit dem Namen action, akzeptiert ein Argument des Typs Object.Three tasks execute an Action<T> delegate named action, which accepts an argument of type Object. Eine vierte-Aufgabe führt einen Lambda-Ausdruck (ein Action Delegaten), Inline definiert im Aufruf der Methode zum Erstellen von Tasks.A fourth task executes a lambda expression (an Action delegate) that is defined inline in the call to the task creation method. Jede Aufgabe instanziiert und auf andere Weise ausführen:Each task is instantiated and run in a different way:

  • Aufgabe t1 durch den Aufruf eines Klassenkonstruktors Aufgabe instanziiert wird, jedoch wird gestartet, durch den Aufruf der Start() Methode nur nach Aufgabe t2 wurde gestartet.Task t1 is instantiated by calling a Task class constructor, but is started by calling its Start() method only after task t2 has started.

  • Aufgabe t2 instanziiert und Schritte in einem einzelnen Methodenaufruf durch Aufrufen der TaskFactory.StartNew(Action<Object>, Object) Methode.Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

  • Aufgabe t3 instanziiert und Schritte in einem einzelnen Methodenaufruf durch Aufrufen der Run(Action) Methode.Task t3 is instantiated and started in a single method call by calling the Run(Action) method.

  • Aufgabe t4 wird synchron im Hauptthread ausgeführt, durch den Aufruf der RunSynchronously() Methode.Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

Da Aufgabe t4 wird synchron ausgeführt. sie führt auf dem Thread der hauptanwendung.Because task t4 executes synchronously, it executes on the main application thread. Die restlichen Aufgaben werden asynchron auf eine oder mehrere Threads im Threadpool in der Regel ausgeführt.The remaining tasks execute asynchronously typically on one or more thread pool threads.

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
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 AufgabeCreating and executing a task

Task Instanzen können auf verschiedene Arten erstellt werden.Task instances may be created in a variety of ways. Die am häufigsten verwendete Ansatz, nämlich verfügbar ab der .NET Framework 4.5.NET Framework 4.5, besteht im Aufrufen der statischen Run Methode.The most common approach, which is available starting with the .NET Framework 4.5.NET Framework 4.5, is to call the static Run method. Die Run Methode bietet eine einfache Möglichkeit zum Starten einer Aufgabe, die unter Verwendung von Standardwerten ohne zusätzliche Parameter.The Run method provides a simple way to start a task using default values and without requiring additional parameters. Im folgenden Beispiel wird die Run(Action) Methode, um eine Aufgabe zu starten, Schleifen und zeigt dann die Anzahl der Schleifeniterationen:The following example uses the Run(Action) method to start a task that loops and then displays the number of loop iterations:

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Run( () => {
                                  // 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
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 am häufigsten verwendete Methode für den Aufgabenstart nutzt .NET Framework 4.NET Framework 4, wird die statische TaskFactory.StartNew Methode.An alternative, and the most common method to start a task in .NET Framework 4.NET Framework 4, is the static TaskFactory.StartNew method. Die Task.Factory -Eigenschaft gibt eine TaskFactory Objekt.The Task.Factory property returns a TaskFactory object. Der Überladungen der TaskFactory.StartNew Methode können Sie angeben, an die Aufgabenerstellungsoptionen und einen Aufgabenplaner zu übergebenden Parameter.Overloads of the TaskFactory.StartNew method let you specify parameters to pass to the task creation options and a task scheduler. Im folgenden Beispiel wird die TaskFactory.StartNew Methode für den Aufgabenstart nutzt.The following example uses the TaskFactory.StartNew method to start a task. Es ist funktionell gleichwertig mit der Code im vorherigen Beispiel.It is functionally equivalent to the code in the previous example.

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
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.For more complete examples, see Task-based Asynchronous Programming.

Trennung von Erstellung und AusführungSeparating task creation and execution

Die Task Klasse stellt außerdem Konstruktoren, die den Task initialisiert, aber nicht planen sie für die Ausführung, bereit.The Task class also provides constructors that initialize the task but that do not schedule it for execution. Aus Leistungsgründen die Task.Run oder TaskFactory.StartNew Methode ist der bevorzugte Mechanismus zum Erstellen und Planen von Berechnungsaufgaben, aber für Szenarien, in denen Erstellung und Planung getrennt werden müssen, können Sie verwenden die Konstruktoren, und rufen dann die Task.Start Methode, um die Aufgabe für die Ausführung zu einem späteren Zeitpunkt zu planen.For performance reasons, the Task.Run or TaskFactory.StartNew method is the preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation and scheduling must be separated, you can use the constructors and then call the Task.Start method to schedule the task for execution at a later time.

Warten auf eine oder mehrere Aufgaben ausführenWaiting for one or more tasks to complete

Da Aufgaben in der Regel asynchron auf einem Threadpoolthread ausgeführt werden, wird die Ausführung des Threads, die erstellt und startet den Task, sobald die Aufgabe instanziiert wurde fortgesetzt.Because tasks typically run asynchronously on a thread pool thread, the thread that creates and starts the task continues execution as soon as the task has been instantiated. In einigen Fällen, wenn der aufrufende Thread der Thread der hauptanwendung, ist die app kann beendet werden vor allen den Task startet die Ausführung tatsächlich.In some cases, when the calling thread is the main application thread, the app may terminate before any the task actually begins execution. In anderen Fällen kann die Logik Ihrer Anwendung erforderlich, dass der aufrufende Thread die Ausführung fortsetzen, nur, wenn eine oder mehrere Aufgaben die Ausführung abgeschlossen hat.In others, your application's logic may require that the calling thread continue execution only when one or more tasks has completed execution. Können Sie die Ausführung des aufrufenden Threads synchronisieren der asynchronen Aufgaben und er startet durch Aufrufen einer Wait Methode warten, eine oder mehrere Aufgaben ausführen.You can synchronize the execution of the calling thread and the asynchronous tasks it launches by calling a Wait method to wait for one or more tasks to complete.

Um für die Durchführung einer einzelnen Aufgabe zu warten, rufen Sie die Task.Wait Methode.To wait for a single task to complete, you can call its Task.Wait method. Ein Aufruf der Wait Methode blockiert den aufrufenden Thread, bis die Instanz der Klasse die Ausführung abgeschlossen hat.A call to the Wait method blocks the calling thread until the single class instance has completed execution.

Im folgenden Beispiel wird die parameterlose Wait() Methode bedingungslos warten, bis eine Aufgabe abgeschlossen ist.The following example calls the parameterless Wait() method to wait unconditionally until a task completes. Die Aufgabe simuliert Arbeit durch Aufrufen der Thread.Sleep Methode für zwei Sekunden in den Ruhezustand.The task simulates work by calling the Thread.Sleep method to sleep for two seconds.

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
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 auf den Abschluss einer Aufgabe warten.You can also conditionally wait for a task to complete. Die Wait(Int32) und Wait(TimeSpan) Methoden blockiert den aufrufenden Thread, bis die Aufgabe abgeschlossen ist oder ein Timeoutintervall abläuft, welcher Fall zuerst eintritt.The Wait(Int32) and Wait(TimeSpan) methods block the calling thread until the task finishes or a timeout interval elapses, whichever comes first. Da im folgende Beispiel wird eine Aufgabe, die zwei Sekunden wartet jedoch definiert einen 1-Sekunden-Timeout-Wert, der aufrufende Thread blockiert gestartet, bis das Timeout abläuft, und bevor ist Ausführung der Aufgabe abgeschlossen werden.Since the following example launches a task that sleeps for two seconds but defines a one-second timeout value, the calling thread blocks until the timeout expires and before the task has completed execution.

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.
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 angeben, durch den Aufruf der Wait(CancellationToken) und Wait(Int32, CancellationToken) Methoden.You can also supply a cancellation token by calling the Wait(CancellationToken) and Wait(Int32, CancellationToken) methods. Wenn des Tokens des IsCancellationRequested -Eigenschaft ist true, der Wartevorgang abgebrochen wird, und wenn es sich bei "true" wird die Wait Methode beendet.If the token's IsCancellationRequested property is true, the wait is cancelled; if it becomes true while the Wait method terminates.

In einigen Fällen möchten Sie möglicherweise warten, für die ersten einer Reihe von Ausführen von Aufgaben abgeschlossen, aber sorgfältig auf die diese Aufgabe ist.In some cases, you may want to wait for the first of a series of executing tasks to complete, but don't care which task it is. Zu diesem Zweck können Sie eine der Überladungen von Aufrufen der Task.WaitAll Methode.For this purpose, you can call one of the overloads of the Task.WaitAll method. Das folgende Beispiel erstellt drei Aufgaben, von denen jeder im Ruhezustand ist für ein Intervall bestimmen, indem Sie einen Zufallszahlengenerator.The following example creates three tasks, each of which sleeps for an interval determine by a random number generator. Die WaitAny(Task[]) Methode wartet, bis die erste Aufgabe ausführen.The WaitAny(Task[]) method waits for the first task to complete. Das Beispiel zeigt anschließend Informationen über den Status aller drei Aufgaben.The example then displays information about the status of all three tasks.

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
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, für alle einer Reihe von Aufgaben durch Aufrufen der WaitAll Methode.You can also wait for all of a series of tasks to complete by calling the WaitAll method. Im folgenden Beispiel werden zehn Aufgaben erstellt, die wartet, bis alle zehn abgeschlossen werden, und klicken Sie dann ihren Status angezeigt.The following example creates ten tasks, waits for all ten to complete, and then displays their status.

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
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 wenn Sie eine oder mehrere Aufgaben zum Abschluss warten, die ausgeführten Aufgaben ausgelöste Ausnahmen für den Thread weitergegeben werden, die aufruft, die Wait Methode, wie im folgenden Beispiel gezeigt.Note that when you wait for one or more tasks to complete, any exceptions thrown in the running tasks are propagated on the thread that calls the Wait method, as the following example shows. Es startet 12 Aufgaben, von denen drei nicht regulär abgeschlossen werden und drei der welche lösen eine Ausnahme.It launches 12 tasks, three of which complete normally and three of which throw an exception. Die verbleibenden sechs Aufgaben werden drei vor dem Start abgebrochen, und drei werden abgebrochen, während sie ausgeführt.Of the remaining six tasks, three are cancelled before the start, and three are cancelled while they executing. Ausnahmen werden ausgelöst, der WaitAll Methodenaufruf und werden anhand einer try / catch Block.Exceptions are thrown in the WaitAll method call and are handled by a try/catch block.

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
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 aufgabenbasierte asynchrone Vorgänge finden Sie unter Exception Handling.For more information on exception handling in task-based asynchronous operations, see Exception Handling.

Aufgaben und KulturTasks and culture

Beginnend mit desktop-apps für die .NET Framework 4.6.NET Framework 4.6, die Kultur des Threads, der erstellt, und ruft eine Aufgabe wird der Kontext des Threads.Starting with desktop apps that target the .NET Framework 4.6.NET Framework 4.6, the culture of the thread that creates and invokes a task becomes part of the thread's context. Unabhängig von der aktuellen Kultur des Threads auf dem der Task ausgeführt wird, ist die aktuelle Kultur der Aufgabe, also die Kultur des aufrufenden Threads.That is, regardless of the current culture of the thread on which the task executes, the current culture of the task is the culture of the calling thread. Für apps mit Zielversionen von .NET Framework vor der .NET Framework 4.6.NET Framework 4.6, die der Aufgabe ist die Kultur des Threads auf dem der Task ausgeführt wird.For apps that target versions of the .NET Framework prior to the .NET Framework 4.6.NET Framework 4.6, the culture of the task is the culture of the thread on which the task executes. Weitere Informationen finden Sie im Abschnitt "Kultur und aufgabenbasierte asynchrone Vorgänge" in der CultureInfo Thema.For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic.

Hinweis

Store-apps, die Windows-Runtime in festlegen und Abrufen der Standardkultur folgen.Store apps follow the Windows Runtime in setting and getting the default culture.

Für DebuggerentwicklerFor debugger developers

Für Entwickler, die benutzerdefinierte Debugger implementieren können mehrere interne und private Member des Tasks hilfreich sein (Dies können sich von Version zu Version ändern).For developers implementing custom debuggers, several internal and private members of task may be useful (these may change from release to release). Die m_taskId Feld dient als Sicherungsspeicher für die Id Eigenschaft jedoch den Zugriff auf dieses Feld direkt von einem Debugger effizienter als der Zugriff auf den gleichen Wert der Eigenschaft Getter-Methode sein kann (die s_taskIdCounter Zähler ist verwendet, um die nächste verfügbare ID für einen Task abrufen).The m_taskId field serves as the backing store for the Id property, however accessing this field directly from a debugger may be more efficient than accessing the same value through the property's getter method (the s_taskIdCounter counter is used to retrieve the next available ID for a task). Auf ähnliche Weise die m_stateFlags Feld speichert Informationen über die aktuelle Lebenszyklusphase der Aufgabe, Informationen, die auch über die Status Eigenschaft.Similarly, the m_stateFlags field stores information about the current lifecycle stage of the task, information also accessible through the Status property. Die m_action Feld speichert einen Verweis auf den Delegaten der Aufgabe, und die m_stateObject Feld speichert den Async-Zustand, der vom Entwickler an die Aufgabe übergeben.The m_action field stores a reference to the task's delegate, and the m_stateObject field stores the async state passed to the task by the developer. Schließlich für den Debugger, die Stapelrahmen, Analysieren der InternalWait Methode dient potenziellen Marker für die bei eine Aufgabe einen Wartevorgang eingibt.Finally, for debuggers that parse stack frames, the InternalWait method serves a potential marker for when a task is entering a wait operation.

Konstruktoren

Task(Action) Task(Action) Task(Action) Task(Action)

Initialisiert eine neue Task mit der angegebenen Aktion. Initializes a new Task with the specified action.

Task(Action, CancellationToken) Task(Action, CancellationToken) Task(Action, CancellationToken) Task(Action, CancellationToken)

Initialisiert eine neue Task mit den angegebenen Werten für Aktion und CancellationToken. Initializes a new Task with the specified action and CancellationToken.

Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions) Task(Action, CancellationToken, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen. Initializes a new Task with the specified action and creation options.

Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions) Task(Action, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen. Initializes a new Task with the specified action and creation options.

Task(Action<Object>, Object) Task(Action<Object>, Object) Task(Action<Object>, Object) Task(Action<Object>, Object)

Initialisiert eine neue Task mit den angegebenen Werten für Aktion und Zustand. Initializes a new Task with the specified action and state.

Task(Action<Object>, Object, CancellationToken) Task(Action<Object>, Object, CancellationToken) Task(Action<Object>, Object, CancellationToken) Task(Action<Object>, Object, CancellationToken)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen. Initializes a new Task with the specified action, state, and options.

Task(Action<Object>, Object, CancellationToken, TaskCreationOptions) Task(Action<Object>, Object, CancellationToken, TaskCreationOptions) Task(Action<Object>, Object, CancellationToken, TaskCreationOptions) Task(Action<Object>, Object, CancellationToken, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen. Initializes a new Task with the specified action, state, and options.

Task(Action<Object>, Object, TaskCreationOptions) Task(Action<Object>, Object, TaskCreationOptions) Task(Action<Object>, Object, TaskCreationOptions) Task(Action<Object>, Object, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen. Initializes a new Task with the specified action, state, and options.

Eigenschaften

AsyncState AsyncState AsyncState AsyncState

Ruft das beim Erstellen der Task angegebene Zustandsobjekt ab, oder NULL, wenn kein Zustandsobjekt angegeben wurde. Gets the state object supplied when the Task was created, or null if none was supplied.

CompletedTask CompletedTask CompletedTask CompletedTask

Ruft eine Aufgabe ab, die bereits erfolgreich abgeschlossen wurde. Gets a task that has already completed successfully.

CreationOptions CreationOptions CreationOptions CreationOptions

Ruft die zum Erstellen dieser Aufgabe verwendeten TaskCreationOptions ab. Gets the TaskCreationOptions used to create this task.

CurrentId CurrentId CurrentId CurrentId

Gibt die ID der momentan ausgeführten Task zurück. Returns the ID of the currently executing Task.

Exception Exception Exception Exception

Ruft die AggregateException ab, die die vorzeitige Beendigung der Task verursacht hat. Gets the AggregateException that caused the Task to end prematurely. Wenn die Task erfolgreich abgeschlossen wurde oder noch keine Ausnahmen ausgelöst wurden, wird null zurückgegeben. If the Task completed successfully or has not yet thrown any exceptions, this will return null.

Factory Factory Factory Factory

Bietet Zugriff auf Factorymethoden zum Erstellen und Konfigurieren von Task- und Task<TResult>-Instanzen. Provides access to factory methods for creating and configuring Task and Task<TResult> instances.

Id Id Id Id

Ruft eine ID für diese Task-Instanz ab. Gets an ID for this Task instance.

IsCanceled IsCanceled IsCanceled IsCanceled

Ruft einen Wert ab, der angibt, ob diese Task-Instanz die Ausführung aufgrund eines Abbruchs abgeschlossen hat. Gets whether this Task instance has completed execution due to being canceled.

IsCompleted IsCompleted IsCompleted IsCompleted

Ruft einen Wert ab, der angibt, ob diese Task abgeschlossen wurde. Gets whether this Task has completed.

IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully
IsFaulted IsFaulted IsFaulted IsFaulted

Ruft einen Wert ab, der angibt, ob die Task aufgrund einer nicht behandelten Ausnahme abgeschlossen wurde. Gets whether the Task completed due to an unhandled exception.

Status Status Status Status

Ruft den TaskStatus dieser Aufgabe ab. Gets the TaskStatus of this task.

Methoden

ConfigureAwait(Boolean) ConfigureAwait(Boolean) ConfigureAwait(Boolean) ConfigureAwait(Boolean)

Konfiguriert einen Awaiter, der verwendet wird, um diese Task zu erwarten. Configures an awaiter used to await this Task.

ContinueWith(Action<Task,Object>, Object) ContinueWith(Action<Task,Object>, Object) ContinueWith(Action<Task,Object>, Object) 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. Creates a continuation that receives caller-supplied state information and executes when the target Task completes.

ContinueWith(Action<Task,Object>, Object, CancellationToken) ContinueWith(Action<Task,Object>, Object, CancellationToken) ContinueWith(Action<Task,Object>, Object, CancellationToken) 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. Creates a continuation that receives caller-supplied state information and a cancellation token and that executes asynchronously when the target Task completes.

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) 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. Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt und verwendet einen angegebenen Zeitplan. The continuation executes based on a set of specified conditions and uses a specified scheduler.

ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions) ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions) ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions) 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. Creates a continuation that receives caller-supplied state information and executes when the target Task completes. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt. The continuation executes based on a set of specified conditions.

ContinueWith(Action<Task,Object>, Object, TaskScheduler) ContinueWith(Action<Task,Object>, Object, TaskScheduler) ContinueWith(Action<Task,Object>, Object, TaskScheduler) 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. Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. Die Fortsetzung verwendet einen angegebenen Zeitplan. The continuation uses a specified scheduler.

ContinueWith(Action<Task>) ContinueWith(Action<Task>) ContinueWith(Action<Task>) ContinueWith(Action<Task>)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Creates a continuation that executes asynchronously when the target Task completes.

ContinueWith(Action<Task>, CancellationToken) ContinueWith(Action<Task>, CancellationToken) ContinueWith(Action<Task>, CancellationToken) ContinueWith(Action<Task>, CancellationToken)

Erstellt eine Fortsetzung, die ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Creates a continuation that receives a cancellation token and executes asynchronously when the target Task completes.

ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Erstellt eine Fortsetzung, die, sobald der Zieltask abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird. Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. Die Fortsetzung empfängt ein Abbruchtoken und verwendet einen angegebenen Zeitplan. The continuation receives a cancellation token and uses a specified scheduler.

ContinueWith(Action<Task>, TaskContinuationOptions) ContinueWith(Action<Task>, TaskContinuationOptions) ContinueWith(Action<Task>, TaskContinuationOptions) ContinueWith(Action<Task>, TaskContinuationOptions)

Erstellt eine Fortsetzung, die, sobald der Zieltask abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird. Creates a continuation that executes when the target task completes according to the specified TaskContinuationOptions.

ContinueWith(Action<Task>, TaskScheduler) ContinueWith(Action<Task>, TaskScheduler) ContinueWith(Action<Task>, TaskScheduler) ContinueWith(Action<Task>, TaskScheduler)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Creates a continuation that executes asynchronously when the target Task completes. Die Fortsetzung verwendet einen angegebenen Zeitplan. The continuation uses a specified scheduler.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object) ContinueWith<TResult>(Func<Task,Object,TResult>, Object) ContinueWith<TResult>(Func<Task,Object,TResult>, Object) 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. Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes and returns a value.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken) 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. Creates a continuation that executes asynchronously when the target Task completes and returns a value. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken. The continuation receives caller-supplied state information and a cancellation token.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Erstellt eine Fortsetzung, die entsprechend den angegebenen Taskfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück. Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken und verwendet den angegebenen Zeitplan. The continuation receives caller-supplied state information and a cancellation token and uses the specified scheduler.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)

Erstellt eine Fortsetzung, die entsprechend den angegebenen Taskfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist. Creates a continuation that executes based on the specified task continuation options when the target Task completes. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen. The continuation receives caller-supplied state information.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler) ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Creates a continuation that executes asynchronously when the target Task completes. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen und verwendet einen angegebenen Zeitplan. The continuation receives caller-supplied state information and uses a specified scheduler.

ContinueWith<TResult>(Func<Task,TResult>) ContinueWith<TResult>(Func<Task,TResult>) ContinueWith<TResult>(Func<Task,TResult>) 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. Creates a continuation that executes asynchronously when the target Task<TResult> completes and returns a value.

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken) 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. Creates a continuation that executes asynchronously when the target Task completes and returns a value. Die Fortsetzung empfängt ein Abbruchtoken. The continuation receives a cancellation token.

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler) 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. Creates a continuation that executes according to the specified continuation options and returns a value. An die Fortsetzung wird ein Abbruchtoken übergeben, und sie verwendet einen angegebenen Zeitplan. The continuation is passed a cancellation token and uses a specified scheduler.

ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions) ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)

Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück. Creates a continuation that executes according to the specified continuation options and returns a value.

ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler) ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler) 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. Creates a continuation that executes asynchronously when the target Task completes and returns a value. Die Fortsetzung verwendet einen angegebenen Zeitplan. The continuation uses a specified scheduler.

Delay(Int32) Delay(Int32) Delay(Int32) Delay(Int32)

Erstellt eine Aufgabe, die nach einer Verzögerung abgeschlossen wird. Creates a task that completes after a time delay.

Delay(Int32, CancellationToken) Delay(Int32, CancellationToken) Delay(Int32, CancellationToken) Delay(Int32, CancellationToken)

Erstellt eine abzubrechende Aufgabe, die nach einer Verzögerung abgeschlossen wird. Creates a cancellable task that completes after a time delay.

Delay(TimeSpan) Delay(TimeSpan) Delay(TimeSpan) Delay(TimeSpan)

Erstellt eine Aufgabe, die nach Ablauf einer festgelegten Zeitspanne abgeschlossen wird. Creates a task that completes after a specified time interval.

Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken) Delay(TimeSpan, CancellationToken)

Erstellt eine abzubrechende Aufgabe, die nach Ablauf einer festgelegten Zeitspanne abgeschlossen wird. Creates a cancellable task that completes after a specified time interval.

Dispose() Dispose() Dispose() Dispose()

Gibt alle von der aktuellen Instanz der Task-Klasse verwendeten Ressourcen frei. Releases all resources used by the current instance of the Task class.

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Verwirft den Task und gibt somit alle von ihm verwendeten nicht verwalteten Ressourcen frei. Disposes the Task, releasing all of its unmanaged resources.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. Determines whether the specified object is equal to the current object.

(Inherited from Object)
FromCanceled(CancellationToken) FromCanceled(CancellationToken) FromCanceled(CancellationToken) FromCanceled(CancellationToken)

Erstellt eine durch Abbruch abgeschlossene Task mit einem angegebenen Abbruchtoken. Creates a Task that's completed due to cancellation with a specified cancellation token.

FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken) FromCanceled<TResult>(CancellationToken)

Erstellt eine durch Abbruch abgeschlossene Task<TResult> mit einem angegebenen Abbruchtoken. Creates a Task<TResult> that's completed due to cancellation with a specified cancellation token.

FromException(Exception) FromException(Exception) FromException(Exception) FromException(Exception)

Erstellt eine durch eine angegebene Ausnahme abgeschlossene Task. Creates a Task that has completed with a specified exception.

FromException<TResult>(Exception) FromException<TResult>(Exception) FromException<TResult>(Exception) FromException<TResult>(Exception)

Erstellt eine durch eine angegebene Ausnahme abgeschlossene Task<TResult>. Creates a Task<TResult> that's completed with a specified exception.

FromResult<TResult>(TResult) FromResult<TResult>(TResult) FromResult<TResult>(TResult) FromResult<TResult>(TResult)

Erstellt eine Task<TResult>, die erfolgreich mit dem angegebenen Ergebnis abgeschlossen wurde. Creates a Task<TResult> that's completed successfully with the specified result.

GetAwaiter() GetAwaiter() GetAwaiter() GetAwaiter()

Ruft einen Awaiter ab, der verwendet wird, um diese Task zu erwarten. Gets an awaiter used to await this Task.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als die Standardhashfunktion. Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab. Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object. Creates a shallow copy of the current Object.

(Inherited from Object)
Run(Action) Run(Action) Run(Action) 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. Queues the specified work to run on the thread pool and returns a Task object that represents that work.

Run(Action, CancellationToken) Run(Action, CancellationToken) Run(Action, CancellationToken) 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. Queues the specified work to run on the thread pool and returns a Task object that represents that work. Ein Abbruchtoken ermöglicht den Abbruch der Arbeit. A cancellation token allows the work to be cancelled.

Run(Func<Task>) Run(Func<Task>) Run(Func<Task>) 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. Queues the specified work to run on the thread pool and returns a proxy for the task returned by function.

Run(Func<Task>, CancellationToken) Run(Func<Task>, CancellationToken) Run(Func<Task>, CancellationToken) 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. Queues the specified work to run on the thread pool and returns a proxy for the task returned by function.

Run<TResult>(Func<Task<TResult>>) Run<TResult>(Func<Task<TResult>>) Run<TResult>(Func<Task<TResult>>) 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. Queues the specified work to run on the thread pool and returns a proxy for the Task(TResult) returned by function.

Run<TResult>(Func<Task<TResult>>, CancellationToken) Run<TResult>(Func<Task<TResult>>, CancellationToken) Run<TResult>(Func<Task<TResult>>, CancellationToken) 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. Queues the specified work to run on the thread pool and returns a proxy for the Task(TResult) returned by function.

Run<TResult>(Func<TResult>) Run<TResult>(Func<TResult>) Run<TResult>(Func<TResult>) 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. Queues the specified work to run on the thread pool and returns a Task<TResult> object that represents that work.

Run<TResult>(Func<TResult>, CancellationToken) Run<TResult>(Func<TResult>, CancellationToken) Run<TResult>(Func<TResult>, CancellationToken) 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. Queues the specified work to run on the thread pool and returns a Task(TResult) object that represents that work. Ein Abbruchtoken ermöglicht den Abbruch der Arbeit. A cancellation token allows the work to be cancelled.

RunSynchronously() RunSynchronously() RunSynchronously() RunSynchronously()

Führt den Task synchron mit dem aktuellen TaskScheduler aus. Runs the Task synchronously on the current TaskScheduler.

RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler) RunSynchronously(TaskScheduler)

Führt die Task synchron mit dem bereitgestellten TaskScheduler aus. Runs the Task synchronously on the TaskScheduler provided.

Start() Start() Start() Start()

Startet die Task und plant ihre Ausführung mit dem aktuellen TaskScheduler. Starts the Task, scheduling it for execution to the current TaskScheduler.

Start(TaskScheduler) Start(TaskScheduler) Start(TaskScheduler) Start(TaskScheduler)

Startet die Task und plant ihre Ausführung mit dem angegebenen TaskScheduler. Starts the Task, scheduling it for execution to the specified TaskScheduler.

ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. Returns a string that represents the current object.

(Inherited from Object)
Wait() Wait() Wait() Wait()

Wartet, bis der Task die Ausführung abschließt. Waits for the Task to complete execution.

Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken) Wait(CancellationToken)

Wartet, bis der Task die Ausführung abschließt. Waits for the Task to complete execution. Der Wartevorgang wird beendet, wenn ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen ist. The wait terminates if a cancellation token is canceled before the task completes.

Wait(Int32) Wait(Int32) Wait(Int32) Wait(Int32)

Wartet darauf, dass die Task innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt wird. Waits for the Task to complete execution within a specified number of milliseconds.

Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken) Wait(Int32, CancellationToken)

Wartet, bis der Task die Ausführung abschließt. Waits for the Task to complete execution. Der Wartevorgang wird beendet, wenn ein Timeoutintervall abläuft oder ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen ist. The wait terminates if a timeout interval elapses or a cancellation token is canceled before the task completes.

Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan) Wait(TimeSpan)

Wartet darauf, dass die Task innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt wird. Waits for the Task to complete execution within a specified time interval.

WaitAll(Task[]) WaitAll(Task[]) WaitAll(Task[]) WaitAll(Task[])

Wartet, bis alle bereitgestellten Task-Objekte die Ausführung abschließen. Waits for all of the provided Task objects to complete execution.

WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken) WaitAll(Task[], CancellationToken)

Wartet, bis alle bereitgestellten Task-Objekte die Ausführung abschließen oder bis der Wartevorgang abgebrochen wird. Waits for all of the provided Task objects to complete execution unless the wait is cancelled.

WaitAll(Task[], Int32) WaitAll(Task[], Int32) WaitAll(Task[], Int32) WaitAll(Task[], Int32)

Wartet darauf, dass alle bereitgestellten Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt werden. Waits for all of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAll(Task[], Int32, CancellationToken) WaitAll(Task[], Int32, CancellationToken) WaitAll(Task[], Int32, CancellationToken) 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. Waits for all of the provided Task objects to complete execution within a specified number of milliseconds or until the wait is cancelled.

WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan) WaitAll(Task[], TimeSpan)

Wartet darauf, dass alle bereitgestellten Task-Objekte, die abgebrochen werden können, innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt werden. Waits for all of the provided cancellable Task objects to complete execution within a specified time interval.

WaitAny(Task[]) WaitAny(Task[]) WaitAny(Task[]) WaitAny(Task[])

Wartet, bis eines der bereitgestellten Task-Objekte die Ausführung abschließt. Waits for any of the provided Task objects to complete execution.

WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken) WaitAny(Task[], CancellationToken)

Wartet, bis bereitgestellte Task-Objekte die Ausführung abschließen oder bis der Wartevorgang abgebrochen wird. Waits for any of the provided Task objects to complete execution unless the wait is cancelled.

WaitAny(Task[], Int32) WaitAny(Task[], Int32) WaitAny(Task[], Int32) WaitAny(Task[], Int32)

Wartet darauf, dass bereitgestellte Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt werden. Waits for any of the provided Task objects to complete execution within a specified number of milliseconds.

WaitAny(Task[], Int32, CancellationToken) WaitAny(Task[], Int32, CancellationToken) WaitAny(Task[], Int32, CancellationToken) 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. Waits for any of the provided Task objects to complete execution within a specified number of milliseconds or until a cancellation token is cancelled.

WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan) WaitAny(Task[], TimeSpan)

Wartet darauf, dass bereitgestellte Task-Objekte, die abgebrochen werden können, innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt werden. Waits for any of the provided Task objects to complete execution within a specified time interval.

WhenAll(IEnumerable<Task>) WhenAll(IEnumerable<Task>) WhenAll(IEnumerable<Task>) WhenAll(IEnumerable<Task>)

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einer aufzählbaren Auflistung abgeschlossen sind. Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[])

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einem Array abgeschlossen sind. Creates a task that will complete when all of the Task objects in an array have completed.

WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>)

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult>-Objekte in einer aufzählbaren Auflistung abgeschlossen sind. Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

WhenAll<TResult>(Task<TResult>[]) WhenAll<TResult>(Task<TResult>[]) WhenAll<TResult>(Task<TResult>[]) WhenAll<TResult>(Task<TResult>[])

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult>-Objekte in einem Array abgeschlossen sind. Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

WhenAny(IEnumerable<Task>) WhenAny(IEnumerable<Task>) WhenAny(IEnumerable<Task>) WhenAny(IEnumerable<Task>)

Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist. Creates a task that will complete when any of the supplied tasks have completed.

WhenAny(Task[]) WhenAny(Task[]) WhenAny(Task[]) WhenAny(Task[])

Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist. Creates a task that will complete when any of the supplied tasks have completed.

WhenAny<TResult>(IEnumerable<Task<TResult>>) WhenAny<TResult>(IEnumerable<Task<TResult>>) WhenAny<TResult>(IEnumerable<Task<TResult>>) WhenAny<TResult>(IEnumerable<Task<TResult>>)

Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist. Creates a task that will complete when any of the supplied tasks have completed.

WhenAny<TResult>(Task<TResult>[]) WhenAny<TResult>(Task<TResult>[]) WhenAny<TResult>(Task<TResult>[]) WhenAny<TResult>(Task<TResult>[])

Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist. Creates a task that will complete when any of the supplied tasks have completed.

Yield() Yield() Yield() Yield()

Erstellt eine Awaitable-Aufgabe, die asynchron an den aktuellen Kontext liefert, wenn erwartet. Creates an awaitable task that asynchronously yields back to the current context when awaited.

Explizite Schnittstellenimplementierungen

IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle IAsyncResult.AsyncWaitHandle

Ruft ein WaitHandle ab, das verwendet werden kann, um auf den Abschluss der Aufgabe zu warten. Gets a WaitHandle that can be used to wait for the task to complete.

IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously IAsyncResult.CompletedSynchronously

Ruft einen Wert ab, der angibt, ob der Vorgang synchron abgeschlossen wurde. Gets an indication of whether the operation completed synchronously.

Gilt für:

Threadsicherheit

Alle Mitglieder der Task, mit Ausnahme von Dispose()sind threadsicher und können von mehreren Threads gleichzeitig verwendet werden. All members of Task, except for Dispose(), are thread-safe and may be used from multiple threads concurrently.

Siehe auch