Task Klasse

Definition

Stellt einen asynchronen Vorgang dar.

public ref class Task : IAsyncResult
public ref class Task : IAsyncResult, IDisposable
public class Task : IAsyncResult
public class Task : IAsyncResult, IDisposable
type Task = class
    interface IAsyncResult
type Task = class
    interface IAsyncResult
    interface IDisposable
Public Class Task
Implements IAsyncResult
Public Class Task
Implements IAsyncResult, IDisposable
Vererbung
Task
Abgeleitet
Implementiert

Hinweise

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

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

Inhalt dieses Abschnitts:

Beispiele für die Instanziierung von Aufgaben
Erstellen und Ausführen einer Aufgabe
Trennen von Aufgabenerstellung und -ausführung
Warten auf den Abschluss einer oder mehrerer Aufgaben
Aufgaben und Kultur
Für Debuggerentwickler

Vorgangsinstanziierung

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

  • Der Task t1 wird durch Aufrufen eines Task-Klassenkonstruktors instanziiert, wird jedoch erst gestartet, indem die Start() -Methode aufgerufen wird, nachdem der Task t2 gestartet wurde.

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

  • Der Task t3 wird instanziiert und in einem einzelnen Methodenaufruf gestartet, indem die Run(Action) -Methode aufgerufen wird.

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

Da der Task t4 synchron ausgeführt wird, wird er im Hauptanwendungsthread ausgeführt. Die restlichen Aufgaben werden in der Regel asynchron in einem oder mehreren Threadpoolthreads ausgeführt.

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

class Example
{
    static void Main()
    {
        Action<object> action = (object obj) =>
                                {
                                   Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                   Task.CurrentId, obj,
                                   Thread.CurrentThread.ManagedThreadId);
                                };

        // Create a task but do not start it.
        Task t1 = new Task(action, "alpha");

        // Construct a started task
        Task t2 = Task.Factory.StartNew(action, "beta");
        // Block the main thread to demonstrate that t2 is executing
        t2.Wait();

        // Launch t1 
        t1.Start();
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId);
        // Wait for the task to finish.
        t1.Wait();

        // Construct a started task using Task.Run.
        String taskData = "delta";
        Task t3 = Task.Run( () => {Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                                     Task.CurrentId, taskData,
                                                      Thread.CurrentThread.ManagedThreadId);
                                   });
        // Wait for the task to finish.
        t3.Wait();

        // Construct an unstarted task
        Task t4 = new Task(action, "gamma");
        // Run it synchronously
        t4.RunSynchronously();
        // Although the task was run synchronously, it is a good practice
        // to wait for it in the event exceptions were thrown by the task.
        t4.Wait();
    }
}
// The example displays output like the following:
//       Task=1, obj=beta, Thread=3
//       t1 has been launched. (Main Thread=1)
//       Task=2, obj=alpha, Thread=4
//       Task=3, obj=delta, Thread=3
//       Task=4, obj=gamma, Thread=1
Imports System.Threading
Imports System.Threading.Tasks

Module Example
    Public Sub Main()
        Dim action As Action(Of Object) = 
              Sub(obj As Object)
                 Console.WriteLine("Task={0}, obj={1}, Thread={2}", 
                 Task.CurrentId, obj,
                 Thread.CurrentThread.ManagedThreadId)
              End Sub

        ' Construct an unstarted task
        Dim t1 As New Task(action, "alpha")

        ' Construct a started task
        Dim t2 As Task = Task.Factory.StartNew(action, "beta")
        ' Block the main thread to demonstrate that t2 is executing
        t2.Wait()

        ' Launch t1 
        t1.Start()
        Console.WriteLine("t1 has been launched. (Main Thread={0})",
                          Thread.CurrentThread.ManagedThreadId)
        ' Wait for the task to finish.
        t1.Wait()

        ' Construct a started task using Task.Run.
        Dim taskData As String = "delta"
        Dim t3 As Task = Task.Run(Sub()
                                     Console.WriteLine("Task={0}, obj={1}, Thread={2}",
                                     Task.CurrentId, taskData,
                                     Thread.CurrentThread.ManagedThreadId)
                                  End Sub)
        ' Wait for the task to finish.
        t3.Wait()
        
        ' Construct an unstarted task
        Dim t4 As New Task(action, "gamma")
        ' Run it synchronously
        t4.RunSynchronously()
        ' Although the task was run synchronously, it is a good practice
        ' to wait for it in the event exceptions were thrown by the task.
        t4.Wait()
    End Sub
End Module
' The example displays output like the following:
'       Task=1, obj=beta, Thread=3
'       t1 has been launched. (Main Thread=1)
'       Task=2, obj=alpha, Thread=3
'       Task=3, obj=delta, Thread=3
'       Task=4, obj=gamma, Thread=1

Erstellen und Ausführen einer Aufgabe

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

using System;
using System.Threading.Tasks;

public class Example
{
   public static async Task Main()
   {
      await Task.Run( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run(Sub()
                                  ' Just loop.
                                  Dim ctr As Integer = 0
                                  For ctr = 0 to 1000000
                                  Next
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays the following output:
'       Finished 1000001 loop iterations

Eine Alternative und die häufigste Methode zum Starten einer Aufgabe in .NET Framework 4 ist die statische TaskFactory.StartNew Methode. Die Task.Factory -Eigenschaft gibt ein TaskFactory -Objekt zurück. Mit Überladungen der TaskFactory.StartNew Methode können Sie Parameter angeben, die an die Aufgabenerstellungsoptionen und einen Aufgabenplaner übergeben werden sollen. Im folgenden Beispiel wird die TaskFactory.StartNew -Methode verwendet, um eine Aufgabe zu starten. Sie entspricht funktional dem Code im vorherigen Beispiel.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Factory.StartNew( () => {
                                  // Just loop.
                                  int ctr = 0;
                                  for (ctr = 0; ctr <= 1000000; ctr++)
                                  {}
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr);
                               } );
      t.Wait();
   }
}
// The example displays the following output:
//        Finished 1000001 loop iterations
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Factory.StartNew(Sub()
                                  ' Just loop.
                                  Dim ctr As Integer = 0
                                  For ctr = 0 to 1000000
                                  Next
                                  Console.WriteLine("Finished {0} loop iterations",
                                                    ctr)
                               End Sub)
      t.Wait()
   End Sub
End Module
' The example displays the following output:
'       Finished 1000001 loop iterations

Ausführlichere Beispiele finden Sie unter Aufgabenbasierte asynchrone Programmierung.

Trennen von Aufgabenerstellung und -ausführung

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

Warten auf den Abschluss einer oder mehrerer Aufgaben

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

Um zu warten, bis eine einzelne Aufgabe abgeschlossen ist, können Sie dessen Task.Wait Methode aufrufen. Ein Aufruf der Wait -Methode blockiert den aufrufenden Thread, bis die Ausführung der einzelnen Klasseninstanz abgeschlossen ist.

Im folgenden Beispiel wird die parameterlose Wait() Methode aufgerufen, um bedingungslos zu warten, bis eine Aufgabe abgeschlossen ist. Der Task simuliert die Arbeit, indem die Methode zwei Sekunden lang in den Thread.Sleep Ruhezustand aufgerufen wird.

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

class Program
{
    static Random rand = new Random();

    static void Main()
    {
        // Wait on a single task with no timeout specified.
        Task taskA = Task.Run( () => Thread.Sleep(2000));
        Console.WriteLine("taskA Status: {0}", taskA.Status);
        try {
          taskA.Wait();
          Console.WriteLine("taskA Status: {0}", taskA.Status);
       } 
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
    }    
}
// The example displays output like the following:
//     taskA Status: WaitingToRun
//     taskA Status: RanToCompletion
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with no timeout specified.
      Dim taskA = Task.Run( Sub() Thread.Sleep(2000))
      Console.WriteLine("taskA Status: {0}", taskA.Status)
      Try
        taskA.Wait()
        Console.WriteLine("taskA Status: {0}", taskA.Status)
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays output like the following:
'     taskA Status: WaitingToRun
'     taskA Status: RanToCompletion

Sie können auch bedingt warten, bis eine Aufgabe abgeschlossen ist. Die Wait(Int32) Methoden und Wait(TimeSpan) blockieren den aufrufenden Thread, bis die Aufgabe abgeschlossen ist oder ein Timeoutintervall verstrichen ist, je nachdem, was zuerst kommt. Da im folgenden Beispiel eine Aufgabe gestartet wird, die zwei Sekunden im Ruhezustand bleibt, aber einen Timeoutwert von einer Sekunde definiert, blockiert der aufrufende Thread, bis das Timeout abläuft und bevor die Ausführung der Aufgabe abgeschlossen ist.

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

public class Example
{
   public static void Main()
   {
      // Wait on a single task with a timeout specified.
      Task taskA = Task.Run( () => Thread.Sleep(2000));
      try {
        taskA.Wait(1000);       // Wait for 1 second.
        bool completed = taskA.IsCompleted;
        Console.WriteLine("Task A completed: {0}, Status: {1}",
                         completed, taskA.Status);
        if (! completed)
           Console.WriteLine("Timed out before task A completed.");                 
       }
       catch (AggregateException) {
          Console.WriteLine("Exception in taskA.");
       }   
   }
}
// The example displays output like the following:
//     Task A completed: False, Status: Running
//     Timed out before task A completed.
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Wait on a single task with a timeout specified.
      Dim taskA As Task = Task.Run( Sub() Thread.Sleep(2000))
      Try
         taskA.Wait(1000)        ' Wait for 1 second.
         Dim completed As Boolean = taskA.IsCompleted
         Console.WriteLine("Task.Completed: {0}, Status: {1}",
                           completed, taskA.Status)
         If Not completed Then 
            Console.WriteLine("Timed out before task A completed.")
         End If                     
      Catch e As AggregateException
         Console.WriteLine("Exception in taskA.")
      End Try
   End Sub
End Module
' The example displays the following output:
'     Task A completed: False, Status: Running
'     Timed out before task A completed.

Sie können auch ein Abbruchtoken bereitstellen, indem Sie die Wait(CancellationToken) Methoden und Wait(Int32, CancellationToken) aufrufen. Wenn die Eigenschaft des IsCancellationRequested Tokens während der Ausführung der Wait -Methode ist true oder wirdtrue, löst die -Methode einen ausOperationCanceledException.

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

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

public class Example
{
   public static void Main()
   {
      var tasks = new Task[3];
      var rnd = new Random();
      for (int ctr = 0; ctr <= 2; ctr++)
         tasks[ctr] = Task.Run( () => Thread.Sleep(rnd.Next(500, 3000)));

      try {
         int index = Task.WaitAny(tasks);
         Console.WriteLine("Task #{0} completed first.\n", tasks[index].Id);
         Console.WriteLine("Status of all tasks:");
         foreach (var t in tasks)
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
      }
      catch (AggregateException) {
         Console.WriteLine("An exception occurred.");
      }
   }
}
// The example displays output like the following:
//     Task #1 completed first.
//     
//     Status of all tasks:
//        Task #3: Running
//        Task #1: RanToCompletion
//        Task #4: Running
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks(2) As Task
      Dim rnd As New Random()
      For ctr As Integer = 0 To 2
         tasks(ctr) = Task.Run( Sub()  Thread.Sleep(rnd.Next(500, 3000)))
      Next
      
      Try 
         Dim index As Integer= Task.WaitAny(tasks)
         Console.WriteLine("Task #{0} completed first.", tasks(index).Id)
         Console.WriteLine()
         Console.WriteLine("Status of all tasks:")
         For Each t in tasks
            Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         Next   
      Catch e As AggregateException
         Console.WriteLine("An exception occurred.")
      End Try
   End Sub
End Module
' The example displays output like the following:
'     Task #1 completed first.
'     
'     Status of all tasks:
'        Task #3: Running
'        Task #1: RanToCompletion
'        Task #4: Running

Sie können auch warten, bis alle Aufgaben abgeschlossen sind, indem Sie die WaitAll -Methode aufrufen. Im folgenden Beispiel werden zehn Aufgaben erstellt, gewartet, bis alle zehn abgeschlossen sind, und dann deren Status angezeigt.

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

public class Example
{
   public static void Main()
   {
      // Wait for all tasks to complete.
      Task[] tasks = new Task[10];
      for (int i = 0; i < 10; i++)
      {
          tasks[i] = Task.Run(() => Thread.Sleep(2000));
      }
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
         Console.WriteLine("One or more exceptions occurred: ");
         foreach (var ex in ae.Flatten().InnerExceptions)
            Console.WriteLine("   {0}", ex.Message);
      }   

      Console.WriteLine("Status of completed tasks:");
      foreach (var t in tasks)
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
   }
}
// The example displays the following output:
//     Status of completed tasks:
//        Task #2: RanToCompletion
//        Task #1: RanToCompletion
//        Task #3: RanToCompletion
//        Task #4: RanToCompletion
//        Task #6: RanToCompletion
//        Task #5: RanToCompletion
//        Task #7: RanToCompletion
//        Task #8: RanToCompletion
//        Task #9: RanToCompletion
//        Task #10: RanToCompletion
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 warten, bis mindestens eine Aufgabe abgeschlossen ist, alle Ausnahmen, die in den ausgeführten Aufgaben ausgelöst werden, für den Thread weitergegeben werden, der die Wait Methode aufruft, wie im folgenden Beispiel gezeigt. Es startet 12 Aufgaben, von denen drei normal abgeschlossen werden und drei von denen eine Ausnahme auslösen. Von den verbleibenden sechs Aufgaben werden drei abgebrochen, bevor sie beginnen, und drei werden während der Ausführung abgebrochen. Ausnahmen werden im WaitAll Methodenaufruf ausgelöst und von einem try/catch Block behandelt.

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

public class Example
{
   public static void Main()
   {
      // Create a cancellation token and cancel it.
      var source1 = new CancellationTokenSource();
      var token1 = source1.Token;
      source1.Cancel();
      // Create a cancellation token for later cancellation.
      var source2 = new CancellationTokenSource();
      var token2 = source2.Token;
       
      // Create a series of tasks that will complete, be cancelled, 
      // timeout, or throw an exception.
      Task[] tasks = new Task[12];
      for (int i = 0; i < 12; i++)
      {
          switch (i % 4) 
          {
             // Task should run to completion.
             case 0:
                tasks[i] = Task.Run(() => Thread.Sleep(2000));
                break;
             // Task should be set to canceled state.
             case 1:   
                tasks[i] = Task.Run( () => Thread.Sleep(2000),
                         token1);
                break;         
             case 2:
                // Task should throw an exception.
                tasks[i] = Task.Run( () => { throw new NotSupportedException(); } );
                break;
             case 3:
                // Task should examine cancellation token.
                tasks[i] = Task.Run( () => { Thread.Sleep(2000); 
                                             if (token2.IsCancellationRequested)
                                                token2.ThrowIfCancellationRequested();
                                             Thread.Sleep(500); }, token2);   
                break;
          }
      }
      Thread.Sleep(250);
      source2.Cancel();
       
      try {
         Task.WaitAll(tasks);
      }
      catch (AggregateException ae) {
          Console.WriteLine("One or more exceptions occurred:");
          foreach (var ex in ae.InnerExceptions)
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message);
       }   

      Console.WriteLine("\nStatus of tasks:");
      foreach (var t in tasks) {
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status);
         if (t.Exception != null) {
            foreach (var ex in t.Exception.InnerExceptions)
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message);
         }
      }
   }
}
// The example displays output like the following:
//   One or more exceptions occurred:
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//      TaskCanceledException: A task was canceled.
//      NotSupportedException: Specified method is not supported.
//      TaskCanceledException: A task was canceled.
//   
//   Status of tasks:
//      Task #13: RanToCompletion
//      Task #1: Canceled
//      Task #3: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #8: Canceled
//      Task #14: RanToCompletion
//      Task #4: Canceled
//      Task #6: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #7: Canceled
//      Task #15: RanToCompletion
//      Task #9: Canceled
//      Task #11: Faulted
//         NotSupportedException: Specified method is not supported.
//      Task #12: Canceled
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Create a cancellation token and cancel it.
      Dim source1 As New CancellationTokenSource()
      Dim token1 As CancellationToken = source1.Token
      source1.Cancel()
      ' Create a cancellation token for later cancellation.
      Dim source2 As New CancellationTokenSource()
      Dim token2 As CancellationToken = source2.Token
       
      ' Create a series of tasks that will complete, be cancelled, 
      ' timeout, or throw an exception.
      Dim tasks(11) As Task
      For i As Integer = 0 To 11
          Select Case i Mod 4 
             ' Task should run to completion.
             Case 0
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000))
             ' Task should be set to canceled state.
             Case 1   
                tasks(i) = Task.Run( Sub() Thread.Sleep(2000), token1)
             Case 2
                ' Task should throw an exception.
                tasks(i) = Task.Run( Sub() 
                                        Throw New NotSupportedException() 
                                     End Sub)
             Case 3
                ' Task should examine cancellation token.
                tasks(i) = Task.Run( Sub() 
                                        Thread.Sleep(2000) 
                                        If token2.IsCancellationRequested
                                           token2.ThrowIfCancellationRequested()
                                        End If
                                        Thread.Sleep(500) 
                                     End Sub, token2)   
          End Select
      Next
      Thread.Sleep(250)
      source2.Cancel()
       
      Try 
         Task.WaitAll(tasks)
      Catch ae As AggregateException
         Console.WriteLine("One or more exceptions occurred:")
         For Each ex in ae.InnerExceptions
             Console.WriteLine("   {0}: {1}", ex.GetType().Name, ex.Message)
         Next
      End Try   
      Console.WriteLine()
      
      Console.WriteLine("Status of tasks:")
      For Each t in tasks
         Console.WriteLine("   Task #{0}: {1}", t.Id, t.Status)
         If t.Exception IsNot Nothing Then
            For Each ex in t.Exception.InnerExceptions
               Console.WriteLine("      {0}: {1}", ex.GetType().Name,
                                 ex.Message)
            Next
         End If
      Next
   End Sub
End Module
' The example displays output like the following:
'   One or more exceptions occurred:
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'      TaskCanceledException: A task was canceled.
'      NotSupportedException: Specified method is not supported.
'      TaskCanceledException: A task was canceled.
'   
'   Status of tasks:
'      Task #13: RanToCompletion
'      Task #1: Canceled
'      Task #3: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #8: Canceled
'      Task #14: RanToCompletion
'      Task #4: Canceled
'      Task #6: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #7: Canceled
'      Task #15: RanToCompletion
'      Task #9: Canceled
'      Task #11: Faulted
'         NotSupportedException: Specified method is not supported.
'      Task #12: Canceled

Weitere Informationen zur Ausnahmebehandlung in aufgabenbasierten asynchronen Vorgängen finden Sie unter Ausnahmebehandlung.

Aufgaben und Kultur

Ab Desktop-Apps, die auf die .NET Framework 4.6 abzielen, wird die Kultur des Threads, der eine Aufgabe erstellt und aufruft, Teil des Kontexts des Threads. Das heißt, unabhängig von der aktuellen Kultur des Threads, in dem die Aufgabe ausgeführt wird, ist die aktuelle Kultur der Aufgabe die Kultur des aufrufenden Threads. Für Apps, die Versionen der .NET Framework vor dem .NET Framework 4.6 als Ziel verwenden, ist die Kultur der Aufgabe die Kultur des Threads, in dem die Aufgabe ausgeführt wird. Weitere Informationen finden Sie im Abschnitt "Kultur und aufgabenbasierte asynchrone Vorgänge" im CultureInfo Thema.

Hinweis

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

Für Debuggerentwickler

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

Konstruktoren

Task(Action)

Initialisiert eine neue Task mit der angegebenen Aktion.

Task(Action, CancellationToken)

Initialisiert eine neue Task mit den angegebenen Werten für Aktion und CancellationToken.

Task(Action, CancellationToken, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.

Task(Action, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion und Erstellungsoptionen.

Task(Action<Object>, Object)

Initialisiert eine neue Task mit den angegebenen Werten für Aktion und Zustand.

Task(Action<Object>, Object, CancellationToken)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.

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

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.

Task(Action<Object>, Object, TaskCreationOptions)

Initialisiert einen neuen Task mit den angegebenen Werten für Aktion, Zustand und Optionen.

Eigenschaften

AsyncState

Ruft das beim Erstellen des Task angegebene Zustandsobjekt ab, oder NULL, wenn kein Zustandsobjekt angegeben wurde.

CompletedTask

Ruft eine Aufgabe ab, die bereits erfolgreich abgeschlossen wurde.

CreationOptions

Ruft die zum Erstellen dieser Aufgabe verwendeten TaskCreationOptions ab.

CurrentId

Gibt die ID der momentan ausgeführten Task zurück.

Exception

Ruft die AggregateException ab, die die vorzeitige Beendigung der Task verursacht hat. Wenn der Task erfolgreich abgeschlossen wurde oder noch keine Ausnahmen ausgelöst wurden, wird null zurückgegeben.

Factory

Bietet Zugriff auf Factorymethoden zum Erstellen und Konfigurieren von Task- und Task<TResult>-Instanzen.

Id

Ruft eine ID für diese Task-Instanz ab.

IsCanceled

Ruft einen Wert ab, der angibt, ob diese Task-Instanz die Ausführung aufgrund eines Abbruchs abgeschlossen hat.

IsCompleted

Ruft einen Wert ab, der angibt, ob die Aufgabe abgeschlossen wurde.

IsCompletedSuccessfully

Ruft ab, ob der Task bis zum Abschluss ausgeführt wurde.

IsFaulted

Ruft einen Wert ab, der angibt, ob die Task aufgrund einer nicht behandelten Ausnahme abgeschlossen wurde.

Status

Ruft den TaskStatus dieser Aufgabe ab.

Methoden

ConfigureAwait(Boolean)

Konfiguriert einen Awaiter, der verwendet wird, um diese Task zu erwarten.

ContinueWith(Action<Task,Object>, Object)

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken empfängt und ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt und verwendet einen angegebenen Zeitplan.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird ausgeführt, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung wird entsprechend einem Satz angegebener Bedingungen ausgeführt.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung verwendet einen angegebenen Zeitplan.

ContinueWith(Action<Task>)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.

ContinueWith(Action<Task>, CancellationToken)

Erstellt eine Fortsetzung, die ein Abbruchtoken empfängt und asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde.

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

Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird. Die Fortsetzung empfängt ein Abbruchtoken und verwendet einen angegebenen Zeitplan.

ContinueWith(Action<Task>, TaskContinuationOptions)

Erstellt eine Fortsetzung, die, sobald die Zielaufgabe abgeschlossen ist, entsprechend den Angaben in TaskContinuationOptions ausgeführt wird.

ContinueWith(Action<Task>, TaskScheduler)

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung verwendet einen angegebenen Zeitplan.

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

Erstellt eine Fortsetzung, die vom Aufrufer bereitgestellte Zustandsinformationen empfängt, und wird asynchron ausgeführt, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken.

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

Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist, und gibt einen Wert zurück. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen sowie ein Abbruchtoken und verwendet den angegebenen Zeitplan.

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

Erstellt eine Fortsetzung, die entsprechend den angegebenen Aufgabenfortsetzungsoptionen ausgeführt wird, wenn der Ziel-Task abgeschlossen ist. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde. Die Fortsetzung empfängt vom Aufrufer bereitgestellte Zustandsinformationen und verwendet einen angegebenen Zeitplan.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task<TResult> abgeschlossen wurde, und gibt einen Wert zurück.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung empfängt ein Abbruchtoken.

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

Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück. An die Fortsetzung wird ein Abbruchtoken übergeben, und sie verwendet einen angegebenen Zeitplan.

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

Erstellt eine Fortsetzung, die entsprechend den angegebenen Fortsetzungsoptionen ausgeführt wird, und gibt einen Wert zurück.

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

Erstellt eine Fortsetzung, die asynchron ausgeführt wird, wenn der Ziel-Task abgeschlossen wurde, und gibt einen Wert zurück. Die Fortsetzung verwendet einen angegebenen Zeitplan.

Delay(Int32)

Erstellt eine Aufgabe, die nach Ablauf einer festgelegten Anzahl an Millisekunden abgeschlossen wird.

Delay(Int32, CancellationToken)

Erstellt eine stornierbare Aufgabe, die nach Ablauf einer festgelegten Anzahl an Millisekunden abgeschlossen wird.

Delay(TimeSpan)

Erstellt eine Aufgabe, die nach Ablauf einer festgelegten Zeitspanne abgeschlossen wird.

Delay(TimeSpan, CancellationToken)

Erstellt eine abzubrechende Aufgabe, die nach Ablauf einer festgelegten Zeitspanne abgeschlossen wird.

Dispose()

Gibt alle von der aktuellen Instanz der Task-Klasse verwendeten Ressourcen frei.

Dispose(Boolean)

Verwirft den Task und gibt somit alle von ihm verwendeten nicht verwalteten Ressourcen frei.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
FromCanceled(CancellationToken)

Erstellt einen durch Abbruch abgeschlossenen Task mit einem angegebenen Abbruchtoken.

FromCanceled<TResult>(CancellationToken)

Erstellt einen durch Abbruch abgeschlossenen Task<TResult> mit einem angegebenen Abbruchtoken.

FromException(Exception)

Erstellt einen durch eine angegebene Ausnahme abgeschlossenen Task.

FromException<TResult>(Exception)

Erstellt einen durch eine angegebene Ausnahme abgeschlossenen Task<TResult>.

FromResult<TResult>(TResult)

Erstellt ein Task<TResult>, die erfolgreich mit dem angegebenen Ergebnis abgeschlossen ist.

GetAwaiter()

Ruft einen Awaiter ab, der verwendet wird, um diese Task zu erwarten.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
Run(Action)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschlange hinzu und gibt ein Task-Objekt zurück, das diese Aufgabe darstellt.

Run(Action, CancellationToken)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschlange hinzu und gibt ein Task-Objekt zurück, das diese Aufgabe darstellt. Ein Abbruchtoken ermöglicht den Abbruch der Arbeit, wenn diese noch nicht begonnen wurde.

Run(Func<Task>)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschleife hinzu und gibt einen Proxy für die Aufgabe zurück, die von function zurückgegeben wird.

Run(Func<Task>, CancellationToken)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschleife hinzu und gibt einen Proxy für die Aufgabe zurück, die von function zurückgegeben wird. Ein Abbruchtoken ermöglicht den Abbruch der Arbeit, wenn diese noch nicht begonnen wurde.

Run<TResult>(Func<Task<TResult>>)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschleife hinzu und gibt einen Proxy für die Task(TResult) zurück, die von function zurückgegeben wird. Ein Abbruchtoken ermöglicht den Abbruch der Arbeit, wenn diese noch nicht begonnen wurde.

Run<TResult>(Func<Task<TResult>>, CancellationToken)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschleife hinzu und gibt einen Proxy für die Task(TResult) zurück, die von function zurückgegeben wird.

Run<TResult>(Func<TResult>)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschlange hinzu und gibt ein Task<TResult>-Objekt zurück, das diese Aufgabe darstellt. Ein Abbruchtoken ermöglicht den Abbruch der Arbeit, wenn diese noch nicht begonnen wurde.

Run<TResult>(Func<TResult>, CancellationToken)

Fügt die angegebene Verarbeitung zur Ausführung im Threadpool der Warteschlange hinzu und gibt ein Task(TResult)-Objekt zurück, das diese Aufgabe darstellt.

RunSynchronously()

Führt den Task synchron mit dem aktuellen TaskScheduler aus.

RunSynchronously(TaskScheduler)

Führt die Task synchron mit dem bereitgestellten TaskScheduler aus.

Start()

Startet die Task und plant ihre Ausführung mit dem aktuellen TaskScheduler.

Start(TaskScheduler)

Startet die Task und plant ihre Ausführung mit dem angegebenen TaskScheduler.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)
Wait()

Wartet, bis der Task die Ausführung abschließt.

Wait(CancellationToken)

Wartet, bis der Task die Ausführung abschließt. Der Wartevorgang wird beendet, wenn ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen ist.

Wait(Int32)

Wartet darauf, dass die Task innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt wird.

Wait(Int32, CancellationToken)

Wartet, bis der Task die Ausführung abschließt. Der Wartevorgang wird beendet, wenn ein Timeoutintervall abläuft oder ein Abbruchtoken abgebrochen wird, bevor die Aufgabe abgeschlossen ist.

Wait(TimeSpan)

Wartet darauf, dass die Task innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt wird.

Wait(TimeSpan, CancellationToken)

Wartet, bis der Task die Ausführung abschließt.

WaitAll(Task[])

Wartet, bis alle bereitgestellten Task-Objekte die Ausführung abschließen.

WaitAll(Task[], CancellationToken)

Wartet, bis alle bereitgestellten Task-Objekte die Ausführung abschließen oder bis der Wartevorgang abgebrochen wird.

WaitAll(Task[], Int32)

Wartet darauf, dass alle bereitgestellten Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt werden.

WaitAll(Task[], Int32, CancellationToken)

Wartet darauf, dass alle bereitgestellten Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden oder vollständig ausgeführt werden, oder bis zum Abbruch des Wartevorgangs.

WaitAll(Task[], TimeSpan)

Wartet darauf, dass alle bereitgestellten Task-Objekte, die abgebrochen werden können, innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt werden.

WaitAny(Task[])

Wartet, bis eines der bereitgestellten Task-Objekte die Ausführung abschließt.

WaitAny(Task[], CancellationToken)

Wartet, bis bereitgestellte Task-Objekte die Ausführung abschließen oder bis der Wartevorgang abgebrochen wird.

WaitAny(Task[], Int32)

Wartet darauf, dass bereitgestellte Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden vollständig ausgeführt werden.

WaitAny(Task[], Int32, CancellationToken)

Wartet darauf, dass bereitgestellte Task-Objekte innerhalb einer angegebenen Anzahl an Millisekunden oder vollständig ausgeführt werden, oder bis ein Abbruchtoken abgebrochen wird.

WaitAny(Task[], TimeSpan)

Wartet darauf, dass bereitgestellte Task-Objekte, die abgebrochen werden können, innerhalb eines angegebenen Zeitintervalls vollständig ausgeführt werden.

WaitAsync(CancellationToken)

Ruft eine Task ab, die abgeschlossen wird, wenn dies Task abgeschlossen ist oder wenn der angegebene CancellationToken Abbruch angefordert wurde.

WaitAsync(TimeSpan)

Ruft eine Task ab, die abgeschlossen wird, wenn dies Task abgeschlossen ist oder das angegebene Timeout abläuft.

WaitAsync(TimeSpan, CancellationToken)

Ruft eine Task ab, die abgeschlossen wird, wenn dies Task abgeschlossen ist, wenn das angegebene Timeout abläuft oder wenn der angegebene CancellationToken Abbruch angefordert wurde.

WhenAll(IEnumerable<Task>)

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einer aufzählbaren Sammlung abgeschlossen sind.

WhenAll(Task[])

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einem Array abgeschlossen sind.

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

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult>-Objekte in einer aufzählbaren Sammlung abgeschlossen sind.

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

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult>-Objekte in einem Array abgeschlossen sind.

WhenAny(IEnumerable<Task>)

Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist.

WhenAny(Task, Task)

Erstellt einen Task, der abgeschlossen wird, wenn einer der angegebenen Tasks abgeschlossen ist.

WhenAny(Task[])

Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist.

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

Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist.

WhenAny<TResult>(Task<TResult>, Task<TResult>)

Erstellt einen Task, der abgeschlossen wird, wenn einer der angegebenen Tasks abgeschlossen ist.

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

Erstellt eine Aufgabe, die abgeschlossen wird, wenn eine der angegebenen Aufgaben abgeschlossen ist.

Yield()

Erstellt eine Awaitable-Aufgabe, die asynchron an den aktuellen Kontext liefert, wenn erwartet.

Explizite Schnittstellenimplementierungen

IAsyncResult.AsyncWaitHandle

Ruft ein WaitHandle ab, das verwendet werden kann, um auf den Abschluss der Aufgabe zu warten.

IAsyncResult.CompletedSynchronously

Ruft einen Wert ab, der angibt, ob der Vorgang synchron abgeschlossen wurde.

Erweiterungsmethoden

DispatcherOperationWait(Task)

Wartet, bis die zugrunde liegende DispatcherOperation abgeschlossen ist.

DispatcherOperationWait(Task, TimeSpan)

Wartet die angegebene Zeitdauer auf den Abschluss der zugrunde liegenden DispatcherOperation.

IsDispatcherOperationTask(Task)

Gibt einen Wert zurück, mit dem angegeben wird, ob eine Task mit einer DispatcherOperation verknüpft ist.

AsAsyncAction(Task)

Gibt eine asynchrone Windows-Runtime-Aktion zurück, die eine begonnene Aufgabe darstellt.

Gilt für:

Threadsicherheit

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

Siehe auch