Task Task Task Task Class

Définition

Représente une opération asynchrone.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
Héritage
TaskTaskTaskTask
Dérivé
Implémente

Remarques

Le Task classe représente une opération unique qui ne retourne pas une valeur et qui généralement exécute de façon asynchrone.The Task class represents a single operation that does not return a value and that usually executes asynchronously. Task les objets sont l’un des composants centrales de la modèle asynchrone basé sur les tâches introduite dans .NET Framework 4.Task objects are one of the central components of the task-based asynchronous pattern first introduced in the .NET Framework 4. Étant donné que le travail effectué par un Task objet généralement exécute de façon asynchrone sur un thread de pool de threads plutôt que de façon synchrone sur le thread principal de l’application, vous pouvez utiliser la Status propriété, ainsi que le IsCanceled, IsCompleted, et IsFaulted propriétés, pour déterminer l’état d’une tâche.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. En règle générale, une expression lambda est utilisée pour spécifier le travail de la tâche consiste à effectuer.Most commonly, a lambda expression is used to specify the work that the task is to perform.

Pour les opérations qui retournent des valeurs, vous utilisez la Task<TResult> classe.For operations that return values, you use the Task<TResult> class.

Dans cette section :In this section:

Exemples d’instanciation de tâche Task instantiation examples
Création et exécution d’une tâche Creating and executing a task
Séparation de la création de tâches et de l’exécution Separating task creation and execution
En attente d’une ou plusieurs tâches Waiting for one or more tasks to complete
Tâches et la culture Tasks and culture
Pour les développeurs de débogueurFor debugger developers

Instanciation de la tâcheTask instantiation

L’exemple suivant crée et exécute les quatre tâches.The following example creates and executes four tasks. Les trois tâches exécutent une Action<T> délégué nommé action, qui accepte un argument de type Object.Three tasks execute an Action<T> delegate named action, which accepts an argument of type Object. Une quatrième tâche exécute une expression lambda (un Action délégué) qui est défini inline dans l’appel à la méthode de création de tâche.A fourth task executes a lambda expression (an Action delegate) that is defined inline in the call to the task creation method. Chaque tâche est instanciée et exécutée dans une autre manière :Each task is instantiated and run in a different way:

  • Tâche t1 est instanciée en appelant un constructeur de classe de tâche, mais est lancée en appelant son Start() méthode uniquement après la tâche t2 a démarré.Task t1 is instantiated by calling a Task class constructor, but is started by calling its Start() method only after task t2 has started.

  • Tâche t2 est instancié et démarrée dans un seul appel de méthode en appelant le TaskFactory.StartNew(Action<Object>, Object) (méthode).Task t2 is instantiated and started in a single method call by calling the TaskFactory.StartNew(Action<Object>, Object) method.

  • Tâche t3 est instancié et démarrée dans un seul appel de méthode en appelant le Run(Action) (méthode).Task t3 is instantiated and started in a single method call by calling the Run(Action) method.

  • Tâche t4 est exécutée de façon synchrone sur le thread principal en appelant le RunSynchronously() (méthode).Task t4 is executed synchronously on the main thread by calling the RunSynchronously() method.

Étant donné que tâche t4 exécute de façon synchrone, elle s’exécute sur le thread principal de l’application.Because task t4 executes synchronously, it executes on the main application thread. Les tâches restantes exécutent de façon asynchrone généralement sur un ou plusieurs threads du pool.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

Création et exécution d’une tâcheCreating and executing a task

Task instances peuvent être créées de plusieurs façons.Task instances may be created in a variety of ways. L’approche la plus courante, qui est disponible à partir de la .NET Framework 4.5.NET Framework 4.5, consiste à appeler la méthode statique Run (méthode).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. Le Run méthode fournit un moyen simple pour démarrer une tâche à l’aide des valeurs par défaut et sans nécessiter des paramètres supplémentaires.The Run method provides a simple way to start a task using default values and without requiring additional parameters. L’exemple suivant utilise la Run(Action) méthode pour démarrer une tâche qui effectue une itération, puis affiche le nombre d’itérations de boucle :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

Une alternative et la méthode la plus courante pour démarrer une tâche dans .NET Framework 4.NET Framework 4, est la méthode statique TaskFactory.StartNew (méthode).An alternative, and the most common method to start a task in .NET Framework 4.NET Framework 4, is the static TaskFactory.StartNew method. Le Task.Factory propriété retourne un TaskFactory objet.The Task.Factory property returns a TaskFactory object. Les surcharges de la TaskFactory.StartNew méthode vous permettre de spécifier des paramètres à passer aux options de création de tâche et un planificateur de tâches.Overloads of the TaskFactory.StartNew method let you specify parameters to pass to the task creation options and a task scheduler. L’exemple suivant utilise la TaskFactory.StartNew méthode pour démarrer une tâche.The following example uses the TaskFactory.StartNew method to start a task. Il est fonctionnellement équivalent au code dans l’exemple précédent.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

Pour obtenir des exemples plus complets, consultez basé sur des tâches de programmation asynchrone.For more complete examples, see Task-based Asynchronous Programming.

Séparation de la création de tâches et de l’exécutionSeparating task creation and execution

Le Task classe fournit également des constructeurs qui initialisent la tâche mais qui ne le planifiez pas pour l’exécution.The Task class also provides constructors that initialize the task but that do not schedule it for execution. Pour des raisons de performances, le Task.Run ou TaskFactory.StartNew méthode est le mécanisme recommandé pour la création et la planification des tâches de calculs, mais pour les scénarios où la création et la planification doivent être séparés, vous pouvez utiliser les constructeurs et appelez ensuite la Task.Start méthode pour planifier la tâche pour l’exécution à un moment ultérieur.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.

En attente d’une ou plusieurs tâchesWaiting for one or more tasks to complete

Étant donné que les tâches généralement exécutent de façon asynchrone sur un thread de pool de thread, le thread qui crée et démarre la tâche continue l’exécution dès que la tâche a été instanciée.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. Dans certains cas, lorsque le thread appelant est le thread principal de l’application, l’application peut se fermer avant tout la tâche commence réellement l’exécution.In some cases, when the calling thread is the main application thread, the app may terminate before any the task actually begins execution. Dans d’autres cas, la logique de votre application peut nécessiter que le thread appelant poursuivre l’exécution uniquement lorsqu’une ou plusieurs tâches a terminé son exécution.In others, your application's logic may require that the calling thread continue execution only when one or more tasks has completed execution. Vous pouvez synchroniser l’exécution du thread appelant et asynchrone tâches il lance en appelant un Wait méthode pour attendre un ou plusieurs tâches à effectuer.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.

Pour attendre une tâche unique se termine, vous pouvez appeler son Task.Wait (méthode).To wait for a single task to complete, you can call its Task.Wait method. Un appel à la Wait méthode bloque le thread appelant jusqu'à ce que l’instance de classe unique a terminé son exécution.A call to the Wait method blocks the calling thread until the single class instance has completed execution.

L’exemple suivant appelle Next sans paramètre Wait() méthode attendre sans condition une tâche se termine.The following example calls the parameterless Wait() method to wait unconditionally until a task completes. La tâche simule le travail en appelant le Thread.Sleep méthode en veille pendant deux secondes.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

Vous pouvez également de manière conditionnelle attendre une tâche se termine.You can also conditionally wait for a task to complete. Le Wait(Int32) et Wait(TimeSpan) méthodes bloquent le thread appelant jusqu'à ce que la tâche se termine ou un intervalle de délai d’expiration est écoulé, le premier prévalant.The Wait(Int32) and Wait(TimeSpan) methods block the calling thread until the task finishes or a timeout interval elapses, whichever comes first. Étant donné que l’exemple suivant lance une tâche qui se met en veille pendant deux secondes, mais définit une valeur de délai d’attente d’une seconde, le thread appelant se bloque jusqu'à ce que le délai d’attente expire et avant la tâche de fin de l’exécution.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.

Vous pouvez également fournir un jeton d’annulation en appelant le Wait(CancellationToken) et Wait(Int32, CancellationToken) méthodes.You can also supply a cancellation token by calling the Wait(CancellationToken) and Wait(Int32, CancellationToken) methods. Si le jeton IsCancellationRequested propriété est true ou devient true tandis que le Wait méthode s’exécute, la méthode lève un OperationCanceledException.If the token's IsCancellationRequested property is true or becomes true while the Wait method is executing, the method throws an OperationCanceledException.

Dans certains cas, vous souhaiterez peut-être attendre pour le premier d’une série de l’exécution de tâches à terminer, mais ne les soins de tâches qu’il est.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. Pour cela, vous pouvez appeler une des surcharges de la Task.WaitAny (méthode).For this purpose, you can call one of the overloads of the Task.WaitAny method. L’exemple suivant crée trois tâches, chacune d’elles est en veille pour un intervalle déterminent par un générateur de nombres aléatoires.The following example creates three tasks, each of which sleeps for an interval determine by a random number generator. Le WaitAny(Task[]) méthode attend que la première tâche se termine.The WaitAny(Task[]) method waits for the first task to complete. L’exemple affiche ensuite des informations sur l’état de toutes les trois tâches.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

Vous pouvez également attendre pour l’ensemble d’une série de tâches à effectuer en appelant le WaitAll (méthode).You can also wait for all of a series of tasks to complete by calling the WaitAll method. L’exemple suivant crée dix tâches, attend que toutes les dix terminer, puis affiche leur état.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

Notez que lorsque vous attendez une ou plusieurs tâches à effectuer, toutes les exceptions levées dans les tâches en cours d’exécution sont propagées sur le thread qui appelle le Wait méthode, comme le montre l’exemple suivant.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. Il lance des 12 tâches, trois d'entre eux se terminer normalement et trois des qui lève une exception.It launches 12 tasks, three of which complete normally and three of which throw an exception. Des six tâches restantes, trois sont annulés avant leur démarrage, et trois sont annulés pendant leur exécution.Of the remaining six tasks, three are cancelled before they start, and three are cancelled while they are executing. Les exceptions sont levées dans le WaitAll appel de méthode et sont gérées par un try / catch bloc.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

Pour plus d’informations sur la gestion des exceptions dans les opérations asynchrones basées sur des tâches, consultez gestion des exceptions.For more information on exception handling in task-based asynchronous operations, see Exception Handling.

Tâches et la cultureTasks and culture

À partir des applications de bureau qui ciblent le .NET Framework 4.6.NET Framework 4.6, la culture du thread qui crée et appelle une tâche devient partie intégrante du contexte du thread.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. Autrement dit, quel que soit la culture actuelle du thread sur lequel la tâche s’exécute, la culture actuelle de la tâche est la culture du thread appelant.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. Pour les applications qui ciblent des versions du .NET Framework antérieures à la .NET Framework 4.6.NET Framework 4.6, la culture de la tâche est la culture du thread sur lequel la tâche s’exécute.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. Pour plus d’informations, consultez la section « Culture et opérations asynchrones basées sur une tâche » dans le CultureInfo rubrique.For more information, see the "Culture and task-based asynchronous operations" section in the CultureInfo topic.

Notes

Applications de Store suivent l’exécution de Windows dans la définition et obtention de la culture par défaut.Store apps follow the Windows Runtime in setting and getting the default culture.

Pour les développeurs de débogueurFor debugger developers

Pour les développeurs qui implémentent des débogueurs personnalisés, plusieurs membres internes et privés de tâche peuvent être utiles (ils peuvent changer à partir d’une version à l’autre).For developers implementing custom debuggers, several internal and private members of task may be useful (these may change from release to release). Le m_taskId champ sert de magasin de stockage pour le Id propriété, toutefois l’accès à ce champ directement à partir d’un débogueur peut être plus efficace que l’accès à la même valeur via la méthode d’accesseur Get de la propriété (la s_taskIdCounter compteur est permet de récupérer le prochain ID disponible pour une tâche).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). De même, le m_stateFlags champ stocke des informations sur l’étape du cycle de vie actuelle de la tâche, informations également accessibles via le Status propriété.Similarly, the m_stateFlags field stores information about the current lifecycle stage of the task, information also accessible through the Status property. Le m_action champ stocke une référence au délégué de la tâche et le m_stateObject champ stocke l’état asynchrone passé à la tâche par le développeur.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. Enfin, pour les débogueurs qui analysent des frames de pile, le InternalWait méthode sert un marqueur potentiel pour quand une tâche entre dans une opération d’attente.Finally, for debuggers that parse stack frames, the InternalWait method serves a potential marker for when a task is entering a wait operation.

Constructeurs

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

Initialise un nouveau Task avec l'action spécifiée.Initializes a new Task with the specified action.

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

Initialise un nouveau Task avec l'action spécifiée et 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)

Initialise une nouvelle Task avec l'action et les options de création spécifiées.Initializes a new Task with the specified action and creation options.

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

Initialise une nouvelle Task avec l'action et les options de création spécifiées.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)

Initialise un nouveau Task avec l'action et l'état spécifiés.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)

Initialise une nouvelle Task avec l'action, l'état et les options spécifiés.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)

Initialise une nouvelle Task avec l'action, l'état et les options spécifiés.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)

Initialise une nouvelle Task avec l'action, l'état et les options spécifiés.Initializes a new Task with the specified action, state, and options.

Propriétés

AsyncState AsyncState AsyncState AsyncState

Obtient l'objet d'état fourni quand la Task a été créée, ou null si aucune n'a été fournie.Gets the state object supplied when the Task was created, or null if none was supplied.

CompletedTask CompletedTask CompletedTask CompletedTask

Obtient une tâche qui s’est déjà terminée correctement.Gets a task that has already completed successfully.

CreationOptions CreationOptions CreationOptions CreationOptions

Obtient les TaskCreationOptions utilisées pour créer cette tâche.Gets the TaskCreationOptions used to create this task.

CurrentId CurrentId CurrentId CurrentId

Retourne l'ID de la Task en cours d'exécution.Returns the ID of the currently executing Task.

Exception Exception Exception Exception

Obtient le AggregateException qui a provoqué l'arrêt prématuré de Task.Gets the AggregateException that caused the Task to end prematurely. Si la Task s'est terminée avec succès ou n'a pas encore levé d'exception, la valeur null est retournée.If the Task completed successfully or has not yet thrown any exceptions, this will return null.

Factory Factory Factory Factory

Fournit l'accès aux méthodes de fabrique pour la création d'instances de Task et de Task<TResult>.Provides access to factory methods for creating and configuring Task and Task<TResult> instances.

Id Id Id Id

Obtient un ID pour cette instance de Task.Gets an ID for this Task instance.

IsCanceled IsCanceled IsCanceled IsCanceled

Indique si cette instance de Task s'est exécutée avec succès suite à une annulation.Gets whether this Task instance has completed execution due to being canceled.

IsCompleted IsCompleted IsCompleted IsCompleted

Obtient une valeur indiquant si la tâche est terminée.Gets a value that indicates whether the task has completed.

IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully IsCompletedSuccessfully
IsFaulted IsFaulted IsFaulted IsFaulted

Indique si la Task s'est terminée suite à une exception non gérée.Gets whether the Task completed due to an unhandled exception.

Status Status Status Status

Obtient le TaskStatus de cette tâche.Gets the TaskStatus of this task.

Méthodes

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

Configure un élément awaiter utilisé pour attendre cette Task.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)

Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute quand le Task cible se termine.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)

Crée une continuation qui reçoit des informations d'état fournies par l'appelant et un jeton d'annulation, et qui s'exécute de façon asynchrone quand le Task cible se termine.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)

Crée une continuation qui reçoit des informations d'état fournies par l'appelant et un jeton d'annulation, et qui s'exécute quand le Task cible se termine.Creates a continuation that receives caller-supplied state information and a cancellation token and that executes when the target Task completes. La continuation s'exécute selon un ensemble de conditions spécifiées et utilise un planificateur spécifié.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)

Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute quand le Task cible se termine.Creates a continuation that receives caller-supplied state information and executes when the target Task completes. La continuation s'exécute selon un ensemble de conditions spécifiées.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)

Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute de façon asynchrone quand le Task cible se termine.Creates a continuation that receives caller-supplied state information and executes asynchronously when the target Task completes. La continuation utilise un planificateur spécifié.The continuation uses a specified scheduler.

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

Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine.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)

Crée une continuation qui reçoit un jeton d'annulation et s'exécute de façon asynchrone quand le Task cible se termine.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)

Crée une continuation qui s’exécute quand la tâche cible se termine conformément au TaskContinuationOptions spécifié.Creates a continuation that executes when the target task competes according to the specified TaskContinuationOptions. La continuation reçoit un jeton d'annulation et utilise un planificateur spécifié.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)

Crée une continuation qui s’exécute quand la tâche cible se termine conformément au TaskContinuationOptions spécifié.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)

Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine.Creates a continuation that executes asynchronously when the target Task completes. La continuation utilise un planificateur spécifié.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)

Crée une continuation qui reçoit des informations d'état fournies par l'appelant et s'exécute de façon asynchrone quand le Task cible se termine et retourne une valeur.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)

Crée une continuation qui s'exécute de façon asynchrone quand le Task cible se termine et retourne une valeur.Creates a continuation that executes asynchronously when the target Task completes and returns a value. La continuation reçoit des informations d'état fournies par l'appelant et un jeton d'annulation.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)

Crée une continuation qui s’exécute en fonction des options de continuation de tâche spécifiées quand le Task cible se termine et retourne une valeur.Creates a continuation that executes based on the specified task continuation options when the target Task completes and returns a value. La continuation reçoit des informations d'état fournies par l'appelant et un jeton d'annulation et elle utilise un planificateur spécifié.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)

Crée une continuation qui s’exécute en fonction des options de continuation de tâche spécifiées quand le Task cible se termine.Creates a continuation that executes based on the specified task continuation options when the target Task completes. La continuation reçoit des informations d'état fournies par l'appelant.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)

Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine.Creates a continuation that executes asynchronously when the target Task completes. La continuation reçoit des informations d'état fournies par l'appelant et utilise un planificateur spécifié.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>)

Crée une continuation qui s'exécute de façon asynchrone quand le Task<TResult> cible se termine et retourne une valeur.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)

Crée une continuation qui s'exécute de façon asynchrone quand le Task cible se termine et retourne une valeur.Creates a continuation that executes asynchronously when the target Task completes and returns a value. La continuation reçoit un jeton d'annulation.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)

Crée une continuation qui s'exécute en fonction des options de continuation spécifiées et retourne une valeur.Creates a continuation that executes according to the specified continuation options and returns a value. La continuation reçoit un jeton d'annulation et utilise un planificateur spécifié.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)

Crée une continuation qui s'exécute en fonction des options de continuation spécifiées et retourne une valeur.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)

Crée une continuation qui s'exécute de façon asynchrone quand le Task cible se termine et retourne une valeur.Creates a continuation that executes asynchronously when the target Task completes and returns a value. La continuation utilise un planificateur spécifié.The continuation uses a specified scheduler.

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

Crée une tâche qui se termine après un nombre spécifié de millisecondes.Creates a task that completes after a specified number of milliseconds.

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

Crée une tâche pouvant être annulée qui se termine après un nombre spécifié de millisecondes.Creates a cancellable task that completes after a specified number of milliseconds.

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

Crée une tâche qui se termine après un intervalle de temps spécifié.Creates a task that completes after a specified time interval.

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

Crée une tâche pouvant être annulée qui se termine après un intervalle de temps spécifié.Creates a cancellable task that completes after a specified time interval.

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

Libère toutes les ressources utilisées par l'instance actuelle de la classe Task.Releases all resources used by the current instance of the Task class.

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

Supprime la Task, en libérant toutes ses ressources non managées.Disposes the Task, releasing all of its unmanaged resources.

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

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

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

Crée une Task qui s'est terminée en raison de l'annulation avec un jeton d'annulation spécifié.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)

Crée une Task<TResult> qui s'est terminée en raison de l'annulation avec un jeton d'annulation spécifié.Creates a Task<TResult> that's completed due to cancellation with a specified cancellation token.

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

Crée une Task qui s'est terminée avec une exception spécifiée.Creates a Task that has completed with a specified exception.

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

Crée une Task<TResult> qui s'est terminée avec une exception spécifiée.Creates a Task<TResult> that's completed with a specified exception.

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

Crée une Task<TResult> qui s'est terminée correctement avec le résultat spécifié.Creates a Task<TResult> that's completed successfully with the specified result.

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

Obtient un élément awaiter utilisé pour attendre cette Task.Gets an awaiter used to await this Task.

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

Fait office de fonction de hachage par défaut.Serves as the default hash function.

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

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

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

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
Run(Action) Run(Action) Run(Action) Run(Action)

Met en file d'attente le travail spécifié à exécuter dans le pool de threads et retourne un objet Task qui représente ce travail.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)

Met en file d'attente le travail spécifié à exécuter dans le pool de threads et retourne un objet Task qui représente ce travail.Queues the specified work to run on the thread pool and returns a Task object that represents that work. Un jeton d’annulation permet l’annulation du travail.A cancellation token allows the work to be cancelled.

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

Met en file d’attente le travail spécifié à exécuter sur le pool de threads et retourne un proxy pour la tâche retournée par function.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)

Met en file d’attente le travail spécifié à exécuter sur le pool de threads et retourne un proxy pour la tâche retournée par function.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>>)

Met en file d’attente le travail spécifié à exécuter dans le pool de threads et retourne un proxy pour le Task(TResult) retourné par function.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)

Met en file d’attente le travail spécifié à exécuter dans le pool de threads et retourne un proxy pour le Task(TResult) retourné par function.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>)

Met en file d'attente le travail spécifié à exécuter dans le pool de threads et retourne un objet Task<TResult> qui représente ce travail.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)

Met en file d'attente le travail spécifié à exécuter dans le pool de threads et retourne un objet Task(TResult) qui représente ce travail.Queues the specified work to run on the thread pool and returns a Task(TResult) object that represents that work. Un jeton d’annulation permet l’annulation du travail.A cancellation token allows the work to be cancelled.

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

Exécute de façon synchrone la Task sur le TaskScheduler actuel.Runs the Task synchronously on the current TaskScheduler.

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

Exécute de façon synchrone le Task sur le TaskScheduler fourni.Runs the Task synchronously on the TaskScheduler provided.

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

Démarre la Task, en planifiant son exécution selon le TaskScheduler actuel.Starts the Task, scheduling it for execution to the current TaskScheduler.

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

Démarre la Task, en planifiant son exécution sur le TaskScheduler spécifié.Starts the Task, scheduling it for execution to the specified TaskScheduler.

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

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

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

Attend la fin de l'exécution de Task.Waits for the Task to complete execution.

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

Attend la fin de l'exécution de Task.Waits for the Task to complete execution. L'attente se termine si un jeton d'annulation est annulé avant la fin de la tâche.The wait terminates if a cancellation token is canceled before the task completes.

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

Attend la fin de l'exécution de la Task en un nombre de millisecondes spécifié.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)

Attend la fin de l'exécution de Task.Waits for the Task to complete execution. L'attente se termine si un intervalle de délai est écoulé ou si un jeton d'annulation est annulé avant la fin de la tâche.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)

Attend la fin de l'exécution de la Task dans un intervalle de temps spécifié.Waits for the Task to complete execution within a specified time interval.

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

Attend la fin de l'exécution de tous les objets Task fournis.Waits for all of the provided Task objects to complete execution.

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

Attend la fin de l'exécution de tous les objets Task fournis sauf si l'attente est annulée.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)

Attend la fin de l'exécution de tous les objets Task fournis en un nombre de millisecondes spécifié.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)

Attend la fin de l'exécution de tous les objets Task fournis en un nombre de millisecondes spécifié ou jusqu'à ce que l'attente soit annulée.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)

Attend la fin de l'exécution de tous les objets Task pouvant être annulés fournis dans un intervalle de temps spécifié.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[])

Attend la fin de l'exécution de l'un des objets Task fournis.Waits for any of the provided Task objects to complete execution.

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

Attend la fin de l'exécution de l'un des objets Task fournis sauf si l'attente est annulée.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)

Attend la fin de l'exécution de l'un des objets Task fournis en un nombre de millisecondes spécifié.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)

Attend la fin de l'exécution de l'un des objets Task fournis en un nombre de millisecondes spécifié ou jusqu'à ce qu'un jeton d'annulation soit annulé.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)

Attend la fin de l'exécution de n'importe lequel des objets Task fournis dans un intervalle de temps spécifié.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>)

Crée une tâche qui s’achève quand tous les objets Task d’une collection énumérable sont terminés.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[])

Crée une tâche qui s’achève quand tous les objets Task d’un tableau sont terminés.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>>)

Crée une tâche qui s’achève quand tous les objets Task<TResult> d’une collection énumérable sont terminés.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>[])

Crée une tâche qui s’achève quand tous les objets Task<TResult> d’un tableau sont terminés.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>)

Crée une tâche qui s’achève quand l’une des tâches fournies est terminée.Creates a task that will complete when any of the supplied tasks have completed.

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

Crée une tâche qui s’achève quand l’une des tâches fournies est terminée.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>>)

Crée une tâche qui s’achève quand l’une des tâches fournies est terminée.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>[])

Crée une tâche qui s’achève quand l’une des tâches fournies est terminée.Creates a task that will complete when any of the supplied tasks have completed.

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

Crée une tâche pouvant être attendue qui se produit de manière asynchrone dans le contexte actuel pendant l’attente.Creates an awaitable task that asynchronously yields back to the current context when awaited.

Implémentations d’interfaces explicites

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

Obtient un WaitHandle qui peut être utilisé en attendant la fin de la tâche.Gets a WaitHandle that can be used to wait for the task to complete.

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

Obtient une indication précisant si l’opération s’est terminée de manière synchrone.Gets an indication of whether the operation completed synchronously.

Extension Methods

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

Attend indéfiniment que l'opération DispatcherOperation sous-jacente se termine.Waits indefinitely for the underlying DispatcherOperation to complete.

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

Attend pendant le délai spécifié que le DispatcherOperation sous-jacente se termine.Waits for the specified amount of time for the underlying DispatcherOperation to complete.

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

Retourne une valeur qui indique si cette Task est associée à une DispatcherOperation.Returns a value that indicates whether this Task is associated with a DispatcherOperation.

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

Retourne une action asynchrone Windows Runtime qui représente une tâche initiée.Returns a Windows Runtime asynchronous action that represents a started task.

S’applique à

Cohérence de thread

Tous les membres de Task, à l’exception de Dispose(), sont thread-safe et peuvent être utilisés à partir de plusieurs threads simultanément.All members of Task, except for Dispose(), are thread-safe and may be used from multiple threads concurrently.

Voir aussi