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 einen einzelnen Vorgang dar, der keinen Wert zurückgibt und in der Regel asynchron ausgeführt wird.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 des aufgabenbasierten asynchronen Musters , das erstmals in .NET Framework 4 eingeführt wurde.Task objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. Da die von einem Task-Objekt ausgeführten Aufgaben in der Regel asynchron in einem Thread Pool Thread anstatt synchron im Hauptanwendungs Thread ausgeführt werden, können Sie die Status-Eigenschaft sowie die Eigenschaften IsCanceled, IsCompleted und IsFaulted verwenden, um bestimmen Sie den Status einer Aufgabe.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, um die Arbeit anzugeben, die vom Task ausgeführt werden soll.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:

Beispiele für die Aufgaben Instanziierung Task instantiation examples
Erstellen und Ausführen einer Aufgabe Creating and executing a task
Trennen der Aufgaben Erstellung und-Ausführung Separating task creation and execution
Es wird auf den Abschluss einer oder mehrerer Aufgaben gewartet.Waiting for one or more tasks to complete
Tasks und Kultur Tasks and culture
Für Debugger-EntwicklerFor debugger developers

Task InstantiierungTask instantiation

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

  • Der Task t1 wird durch Aufrufen eines taskklassenkonstruktors instanziiert, wird jedoch durch Aufrufen seiner Start()-Methode erst gestartet, nachdem Task t2 gestartet wurde.Task t1 is instantiated by calling a Task class constructor, but is started by calling its Start() method only after task t2 has started.

  • Der Task t2 wird in einem einzelnen Methodenaufruf instanziiert und gestartet, indem die TaskFactory.StartNew(Action<Object>, Object)-Methode aufgerufen wird.Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

  • Der Task t3 wird in einem einzelnen Methodenaufruf instanziiert und gestartet, indem die Run(Action)-Methode aufgerufen wird.Task t3 is instantiated and started in a single method call by calling the Run(Action) method.

  • Der Task t4 wird synchron auf dem Haupt Thread ausgeführt, indem die RunSynchronously()-Methode aufgerufen wird.Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

Da Task t4 synchron ausgeführt wird, wird Sie im Hauptanwendungs Thread ausgeführt.Because task t4 executes synchronously, it executes on the main application thread. Die restlichen Aufgaben werden in der Regel asynchron in einem oder mehreren Threads des Thread Pools 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 unterschiedlichste Weise erstellt werden.Task instances may be created in a variety of ways. Der häufigste Ansatz, der ab dem .NET Framework 4.5.NET Framework 4.5 verfügbar ist, besteht darin, die statische Run-Methode aufzurufen.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, um eine Aufgabe mit Standardwerten zu starten, ohne dass zusätzliche Parameter erforderlich sind.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 verwendet, um eine Aufgabe zu starten, die eine Schleife durchläuft und dann die Anzahl der Schleifen Iterationen anzeigt: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 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
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 gängigste Methode zum Starten einer Aufgabe in .NET Framework 4.NET Framework 4 ist 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 ein TaskFactory-Objekt zurück.The Task.Factory property returns a TaskFactory object. Über Ladungen der TaskFactory.StartNew-Methode ermöglicht Ihnen das Angeben von Parametern, die an die Aufgaben Erstellungs Optionen und einen Aufgabenplaner übergeben werden.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 verwendet, um eine Aufgabe zu starten.The following example uses the TaskFactory.StartNew method to start a task. Es ist funktional äquivalent zum 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.

Trennen der Aufgaben Erstellung und-AusführungSeparating task creation and execution

Die Task-Klasse stellt auch Konstruktoren bereit, die die Aufgabe initialisieren, diese aber nicht für die Ausführung planen.The Task class also provides constructors that initialize the task but that do not schedule it for execution. Aus Leistungsgründen ist die Task.Run-oder TaskFactory.StartNew-Methode der bevorzugte Mechanismus zum Erstellen und Planen von Rechenaufgaben. in Szenarios, in denen die Erstellung und die Zeitplanung getrennt werden müssen, können Sie jedoch die-Konstruktoren verwenden und dann die Task.Start-Methode aufzurufen. , wenn die Aufgabe zu einem späteren Zeitpunkt für die Ausführung geplant werden soll.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.

Es wird auf den Abschluss einer oder mehrerer Aufgaben gewartet.Waiting for one or more tasks to complete

Da Aufgaben in der Regel asynchron in einem Thread Pool Thread ausgeführt werden, wird der Thread, der die Aufgabe erstellt und startet, mit der Ausführung fortgesetzt, sobald die Aufgabe instanziiert wurde.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 aufrufenden Thread der Hauptanwendungs Thread ist, kann die APP beendet werden, bevor die Ausführung der Aufgabe tatsächlich beginnt.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 es bei der Logik ihrer Anwendung erforderlich sein, dass der aufrufenden Thread die Ausführung nur dann fortsetzt, wenn eine oder mehrere Tasks die Ausführung abgeschlossen haben.In others, your application's logic may require that the calling thread continue execution only when one or more tasks has completed execution. Sie können die Ausführung des aufrufenden Threads und der asynchronen Aufgaben, die gestartet werden, synchronisieren, indem Sie eine Wait-Methode aufrufen, um auf den Abschluss einer oder mehrerer Aufgaben zu warten.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 auf den Abschluss einer einzelnen Aufgabe zu warten, können Sie die zugehörige Task.Wait-Methode aufzurufen.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 Ausführung der einzelnen Klasseninstanz abgeschlossen ist.A call to the Wait method blocks the calling thread until the single class instance has completed execution.

Im folgenden Beispiel wird die Parameter lose Wait()-Methode aufgerufen, um bedingungslos zu warten, bis eine Aufgabe abgeschlossen ist.The following example calls the parameterless Wait() method to wait unconditionally until a task completes. Der Task simuliert arbeiten durch Aufrufen der Thread.Sleep-Methode, um zwei Sekunden lang in den Standbymodus zu wechseln.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 Methoden Wait(Int32) und Wait(TimeSpan) blockieren den aufrufenden Thread, bis die Aufgabe abgeschlossen ist oder ein Timeout Intervall abläuft, je nachdem, was 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 folgenden Beispiel eine Aufgabe gestartet wird, die für zwei Sekunden gesperrt ist, aber einen Timeout Wert von einer Sekunde definiert, wird der aufrufende Thread blockiert, bis das Timeout abläuft und bevor die Ausführung der Aufgabe abgeschlossen ist.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 Abbruch Token bereitstellen, indem Sie die Methoden Wait(CancellationToken) und Wait(Int32, CancellationToken) aufrufen.You can also supply a cancellation token by calling the Wait(CancellationToken) and Wait(Int32, CancellationToken) methods. Wenn die IsCancellationRequested-Eigenschaft des Tokens true ist oder true wird, während die Wait-Methode ausgeführt wird, löst die Methode eine OperationCanceledException aus.If the token's IsCancellationRequested property is true or becomes true while the Wait method is executing, the method throws an OperationCanceledException.

In einigen Fällen möchten Sie möglicherweise warten, bis die erste Ausführung einer Reihe von Tasks ausgeführt wird, aber es ist nicht wichtig, welche Aufgabe es 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 über Ladungen der Task.WaitAny-Methode abrufen.For this purpose, you can call one of the overloads of the Task.WaitAny method. Im folgenden Beispiel werden drei Aufgaben erstellt, die jeweils für ein Intervall, das von einem Zufallszahlengenerator bestimmt wird, in Ruhezustand sind.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 beendet ist.The WaitAny(Task[]) method waits for the first task to complete. Im Beispiel werden dann Informationen zum Status aller drei Aufgaben angezeigt.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, bis eine Reihe von Aufgaben durch Aufrufen der WaitAll-Methode vollständig ausgeführt wurde.You can also wait for all of a series of tasks to complete by calling the WaitAll method. Im folgenden Beispiel werden zehn Tasks erstellt, auf den Abschluss aller zehn Tasks gewartet und dann der 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 beim Warten auf den Abschluss einer oder mehrerer Aufgaben alle Ausnahmen, die in den ausgelaufenden Tasks ausgelöst werden, in dem Thread weitergegeben werden, der die Wait-Methode aufruft, 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. Dabei werden 12 Aufgaben gestartet, von denen drei normal ausgeführt werden und drei eine Ausnahme auslösen.It launches 12 tasks, three of which complete normally and three of which throw an exception. Von den verbleibenden sechs Aufgaben werden drei abgebrochen, bevor Sie gestartet werden, und drei werden während der Ausführung abgebrochen.Of the remaining six tasks, three are cancelled before they start, and three are cancelled while they are executing. Im WaitAll-Methodenaufrufe werden Ausnahmen ausgelöst, die von einem try/catch-Block behandelt werden.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 aufgabenbasierten asynchronen Vorgängen finden Sie unter Ausnahmebehandlung.For more information on exception handling in task-based asynchronous operations, see Exception Handling.

Aufgaben und KulturTasks and culture

Beginnend mit Desktop-Apps, die auf .NET Framework 4.6.NET Framework 4.6 abzielen, wird die Kultur des Threads, der einen Task erstellt und aufruft, Teil des Thread Kontexts.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. 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.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, die auf Versionen des .NET Framework vor dem .NET Framework 4.6.NET Framework 4.6 abzielen, ist die Kultur der Aufgabe die Kultur des Threads, in dem die Aufgabe 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" im Thema CultureInfo.For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic.

Hinweis

Store-Apps folgen den Windows-Runtime unter Festlegen und erhalten der Standard Kultur.Store apps follow the Windows Runtime in setting and getting the default culture.

Für Debugger-EntwicklerFor debugger developers

Für Entwickler, die benutzerdefinierte debuggger implementieren, können mehrere interne und private Member der Aufgabe nützlich sein (diese können sich von Release zu Release ändern).For developers implementing custom debuggers, several internal and private members of task may be useful (these may change from release to release). Das Feld "m_taskId" dient als Sicherungs Speicher für die Eigenschaft "Id". der Zugriff auf dieses Feld direkt von einem Debugger kann jedoch effizienter sein als der Zugriff auf denselben Wert über die Getter-s_taskIdCounter Methode der Eigenschaft. Verfügbare ID für eine Aufgabe).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). Entsprechend speichert das Feld m_stateFlags Informationen zur aktuellen Lebenszyklusphase der Aufgabe, auf die Informationen auch über die Status-Eigenschaft zugegriffen werden kann.Similarly, the m_stateFlags field stores information about the current lifecycle stage of the task, information also accessible through the Status property. Im Feld "m_action" wird ein Verweis auf den Delegaten der Aufgabe gespeichert, und im Feld "m_stateObject" wird der asynchrone Zustand gespeichert, der vom Entwickler an die Aufgabe übermittelt wurde.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 stellt die InternalWait-Methode für debuggger, die Stapel Rahmen analysieren, eine potenzielle Markierung für den Fall dar, dass eine Aufgabe in einen Warte Vorgang wechselt.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 des 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 der 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 die Aufgabe abgeschlossen wurde.Gets a value that indicates whether the task has completed.

IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully

Ruft ab, ob der Task bis zum Abschluss ausgeführt wurde.Gets whether the task ran to completion.

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 die Zielaufgabe 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 die Zielaufgabe 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 Aufgabenfortsetzungsoptionen 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 Aufgabenfortsetzungsoptionen 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 Ablauf einer festgelegten Anzahl an Millisekunden abgeschlossen wird.Creates a task that completes after a specified number of milliseconds.

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

Erstellt eine stornierbare Aufgabe, die nach Ablauf einer festgelegten Anzahl an Millisekunden abgeschlossen wird.Creates a cancellable task that completes after a specified number of milliseconds.

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 einen durch Abbruch abgeschlossenen 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 einen durch Abbruch abgeschlossenen 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 einen durch eine angegebene Ausnahme abgeschlossenen Task.Creates a Task that has completed with a specified exception.

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

Erstellt einen durch eine angegebene Ausnahme abgeschlossenen 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 ein Task<TResult>, die erfolgreich mit dem angegebenen Ergebnis abgeschlossen ist.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 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 Sammlung 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 Sammlung 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 einen Awaitable-Task, das asynchron an den aktuellen Kontext liefert, wenn erwartet wird.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.

Erweiterungsmethoden

DispatcherOperationWait(Task) DispatcherOperationWait(Task) DispatcherOperationWait(Task) DispatcherOperationWait(Task)

Wartet, bis die zugrunde liegende DispatcherOperation abgeschlossen ist.Waits indefinitely for the underlying DispatcherOperation to complete.

DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan) DispatcherOperationWait(Task, TimeSpan)

Wartet die angegebene Zeitdauer auf den Abschluss der zugrunde liegenden DispatcherOperation.Waits for the specified amount of time for the underlying DispatcherOperation to complete.

IsDispatcherOperationTask(Task) IsDispatcherOperationTask(Task) IsDispatcherOperationTask(Task) IsDispatcherOperationTask(Task)

Gibt einen Wert zurück, mit dem angegeben wird, ob eine Task mit einer DispatcherOperation verknüpft ist.Returns a value that indicates whether this Task is associated with a DispatcherOperation.

AsAsyncAction(Task) AsAsyncAction(Task) AsAsyncAction(Task) AsAsyncAction(Task)

Gibt eine asynchrone Windows-Runtime-Aktion zurück, die eine begonnene Aufgabe darstellt.Returns a Windows Runtime asynchronous action that represents a started task.

Gilt für:

Threadsicherheit

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

Siehe auch