Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Task classe

 

Date de publication : novembre 2016

Représente une opération asynchrone.

Pour parcourir le code source .NET Framework pour ce type, consultez la Reference Source.

Espace de noms:   System.Threading.Tasks
Assembly:  mscorlib (dans mscorlib.dll)


[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public class Task : IAsyncResult, IDisposable

NomDescription
System_CAPS_pubmethodTask(Action)

Initialise un nouveau Task avec l'action spécifiée.

System_CAPS_pubmethodTask(Action, CancellationToken)

Initialise un nouveau Task avec l'action spécifiée et CancellationToken.

System_CAPS_pubmethodTask(Action, CancellationToken, TaskCreationOptions)

Initialise une nouvelle Task avec l'action et les options de création spécifiées.

System_CAPS_pubmethodTask(Action, TaskCreationOptions)

Initialise une nouvelle Task avec l'action et les options de création spécifiées.

System_CAPS_pubmethodTask(Action<Object>, Object)

Initialise un nouveau Task avec l'action et l'état spécifiés.

System_CAPS_pubmethodTask(Action<Object>, Object, CancellationToken)

Initialise une nouvelle Task avec l'action, l'état et les options spécifiés.

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

Initialise une nouvelle Task avec l'action, l'état et les options spécifiés.

System_CAPS_pubmethodTask(Action<Object>, Object, TaskCreationOptions)

Initialise une nouvelle Task avec l'action, l'état et les options spécifiés.

NomDescription
System_CAPS_pubpropertyAsyncState

Obtient l'objet d'état fourni quand la Task a été créée, ou null si aucune n'a été fournie.

System_CAPS_pubpropertySystem_CAPS_staticCompletedTask

Obtient une tâche qui s’est déjà terminée correctement.

System_CAPS_pubpropertyCreationOptions

Obtient les TaskCreationOptions utilisées pour créer cette tâche.

System_CAPS_pubpropertySystem_CAPS_staticCurrentId

Retourne l'ID de la Task en cours d'exécution.

System_CAPS_pubpropertyException

Obtient le AggregateException qui a provoqué l'arrêt prématuré de Task. Si la Task s'est terminée avec succès ou n'a pas encore levé d'exception, la valeur null est retournée.

System_CAPS_pubpropertySystem_CAPS_staticFactory

Fournit l'accès aux méthodes de fabrique pour la création d'instances de Task et de Task<TResult>.

System_CAPS_pubpropertyId

Obtient un ID pour cette instance de Task.

System_CAPS_pubpropertyIsCanceled

Indique si cette instance de Task s'est exécutée avec succès suite à une annulation.

System_CAPS_pubpropertyIsCompleted

Indique si cette Task s'est terminée.

System_CAPS_pubpropertyIsFaulted

Indique si la Task s'est terminée suite à une exception non gérée.

System_CAPS_pubpropertyStatus

Obtient le TaskStatus de cette tâche.

NomDescription
System_CAPS_pubmethodConfigureAwait(Boolean)

Configure un élément awaiter utilisé pour attendre cette Task.

System_CAPS_pubmethodContinueWith(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.

System_CAPS_pubmethodContinueWith(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.

System_CAPS_pubmethodContinueWith(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. La continuation s'exécute selon un ensemble de conditions spécifiées et utilise un planificateur spécifié.

System_CAPS_pubmethodContinueWith(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. La continuation s'exécute selon un ensemble de conditions spécifiées.

System_CAPS_pubmethodContinueWith(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. La continuation utilise un planificateur spécifié.

System_CAPS_pubmethodContinueWith(Action<Task>)

Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine.

System_CAPS_pubmethodContinueWith(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.

System_CAPS_pubmethodContinueWith(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é. La continuation reçoit un jeton d'annulation et utilise un planificateur spécifié.

System_CAPS_pubmethodContinueWith(Action<Task>, TaskContinuationOptions)

Crée une continuation qui s'exécute quand la tâche cible se termine conformément au TaskContinuationOptions spécifié.

System_CAPS_pubmethodContinueWith(Action<Task>, TaskScheduler)

Crée une continuation qui s'exécute de façon asynchrone quand la Task cible se termine. La continuation utilise un planificateur spécifié.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<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. La continuation reçoit un jeton d'annulation.

System_CAPS_pubmethodContinueWith<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. La continuation reçoit un jeton d'annulation et utilise un planificateur spécifié.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<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. La continuation utilise un planificateur spécifié.

System_CAPS_pubmethodContinueWith<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.

System_CAPS_pubmethodContinueWith<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. La continuation reçoit des informations d'état fournies par l'appelant et un jeton d'annulation.

System_CAPS_pubmethodContinueWith<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. La continuation reçoit des informations d'état fournies par l'appelant et un jeton d'annulation et elle utilise un planificateur spécifié.

System_CAPS_pubmethodContinueWith<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 et retourne une valeur. La continuation reçoit des informations d'état fournies par l'appelant.

System_CAPS_pubmethodContinueWith<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. La continuation reçoit des informations d'état fournies par l'appelant et utilise un planificateur spécifié.

System_CAPS_pubmethodSystem_CAPS_staticDelay(Int32)

Crée une tâche qui se termine après un certain délai.

System_CAPS_pubmethodSystem_CAPS_staticDelay(Int32, CancellationToken)

Crée une tâche pouvant être annulée qui se termine après un certain délai.

System_CAPS_pubmethodSystem_CAPS_staticDelay(TimeSpan)

Crée une tâche qui se termine après un intervalle de temps spécifié.

System_CAPS_pubmethodSystem_CAPS_staticDelay(TimeSpan, CancellationToken)

Crée une tâche pouvant être annulée qui se termine après un intervalle de temps spécifié.

System_CAPS_pubmethodDispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe Task.

System_CAPS_protmethodDispose(Boolean)

Supprime la Task, en libérant toutes ses ressources non managées.

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodFinalize()

Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)

System_CAPS_pubmethodSystem_CAPS_staticFromCanceled(CancellationToken)

Crée une Task qui s'est terminée en raison de l'annulation avec un jeton d'annulation spécifié.

System_CAPS_pubmethodSystem_CAPS_staticFromCanceled<TResult>(CancellationToken)

Crée une Task<TResult> qui s'est terminée en raison de l'annulation avec un jeton d'annulation spécifié.

System_CAPS_pubmethodSystem_CAPS_staticFromException(Exception)

Crée une Task qui s'est terminée avec une exception spécifiée.

System_CAPS_pubmethodSystem_CAPS_staticFromException<TResult>(Exception)

Crée une Task<TResult> qui s'est terminée avec une exception spécifiée.

System_CAPS_pubmethodSystem_CAPS_staticFromResult<TResult>(TResult)

Crée une Task<TResult> qui s'est terminée correctement avec le résultat spécifié.

System_CAPS_pubmethodGetAwaiter()

Obtient un élément awaiter utilisé pour attendre cette Task.

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_pubmethodSystem_CAPS_staticRun(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.

System_CAPS_pubmethodSystem_CAPS_staticRun(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. Un jeton d’annulation permet l’annulation du travail.

System_CAPS_pubmethodSystem_CAPS_staticRun(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.

System_CAPS_pubmethodSystem_CAPS_staticRun(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.

System_CAPS_pubmethodSystem_CAPS_staticRun<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.

System_CAPS_pubmethodSystem_CAPS_staticRun<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. Un jeton d’annulation permet l’annulation du travail.

System_CAPS_pubmethodSystem_CAPS_staticRun<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.

System_CAPS_pubmethodSystem_CAPS_staticRun<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.

System_CAPS_pubmethodRunSynchronously()

Exécute de façon synchrone la Task sur le TaskScheduler actuel.

System_CAPS_pubmethodRunSynchronously(TaskScheduler)

Exécute de façon synchrone le Task sur le TaskScheduler fourni.

System_CAPS_pubmethodStart()

Démarre la Task, en planifiant son exécution selon le TaskScheduler actuel.

System_CAPS_pubmethodStart(TaskScheduler)

Démarre la Task, en planifiant son exécution sur le TaskScheduler spécifié.

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

System_CAPS_pubmethodWait()

Attend la fin de l'exécution de Task.

System_CAPS_pubmethodWait(CancellationToken)

Attend la fin de l'exécution de Task. L'attente se termine si un jeton d'annulation est annulé avant la fin de la tâche.

System_CAPS_pubmethodWait(Int32)

Attend la fin de l'exécution de la Task en un nombre de millisecondes spécifié.

System_CAPS_pubmethodWait(Int32, CancellationToken)

Attend la fin de l'exécution de Task. 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.

System_CAPS_pubmethodWait(TimeSpan)

Attend la fin de l'exécution de la Task dans un intervalle de temps spécifié.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[])

Attend la fin de l'exécution de tous les objets Task fournis.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], CancellationToken)

Attend la fin de l'exécution de tous les objets Task fournis sauf si l'attente est annulée.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(Task[], Int32)

Attend la fin de l'exécution de tous les objets Task fournis en un nombre de millisecondes spécifié.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(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.

System_CAPS_pubmethodSystem_CAPS_staticWaitAll(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é.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[])

Attend la fin de l'exécution de l'un des objets Task fournis.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], CancellationToken)

Attend la fin de l'exécution de l'un des objets Task fournis sauf si l'attente est annulée.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], Int32)

Attend la fin de l'exécution de l'un des objets Task fournis en un nombre de millisecondes spécifié.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(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é.

System_CAPS_pubmethodSystem_CAPS_staticWaitAny(Task[], TimeSpan)

Attend la fin de l'exécution de n'importe lequel des objets Task fournis dans un intervalle de temps spécifié.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll(IEnumerable<Task>)

Crée une tâche qui s'achève quand tous les objets Task d'une collection énumérable sont terminés.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll(Task[])

Crée une tâche qui s'achève quand tous les objets Task d'un tableau sont terminés.

System_CAPS_pubmethodSystem_CAPS_staticWhenAll<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.

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

Crée une tâche qui s'achève quand tous les objets Task<TResult> d'un tableau sont terminés.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny(IEnumerable<Task>)

Crée une tâche qui s’achève quand l’une des tâches fournies est terminée.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny(Task[])

Crée une tâche qui s’achève quand l’une des tâches fournies est terminée.

System_CAPS_pubmethodSystem_CAPS_staticWhenAny<TResult>(IEnumerable<Task<TResult>>)

Crée une tâche qui s’achève quand l’une des tâches fournies est terminée.

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

Crée une tâche qui s’achève quand l’une des tâches fournies est terminée.

System_CAPS_pubmethodSystem_CAPS_staticYield()

Crée une tâche pouvant être attendue qui se produit de manière asynchrone dans le contexte actuel pendant l’attente.

NomDescription
System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAsyncResult.AsyncWaitHandle

Obtient un WaitHandle qui peut être utilisé en attendant la fin de la tâche.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIAsyncResult.CompletedSynchronously

Obtient une indication précisant si l’opération s’est terminée de manière synchrone.

NomDescription
System_CAPS_pubmethodDispatcherOperationWait()

Surchargé. Attend indéfiniment sous-jacent DispatcherOperation pour terminer.(Défini par TaskExtensions.)

System_CAPS_pubmethodDispatcherOperationWait(TimeSpan)

Surchargé. Attend que le laps de temps pour sous-jacent DispatcherOperation pour terminer.(Défini par TaskExtensions.)

System_CAPS_pubmethodIsDispatcherOperationTask()

Retourne une valeur qui indique si cette Task est associé à un DispatcherOperation.(Défini par TaskExtensions.)

System_CAPS_noteRemarque

Pour afficher le code source .NET Framework pour ce type, consultez la Reference Source. Vous pouvez parcourir le code source en ligne, télécharger la référence hors connexion et parcourir les sources (y compris les correctifs et mises à jour) pendant le débogage ; see instructions.

La 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. Task les objets sont parmi les composants centraux de la modèle asynchrone basé sur des tâches introduite dans .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 d’application principal, vous pouvez utiliser le Status propriété, ainsi que le IsCanceled, IsCompleted, et IsFaulted Propriétés, pour déterminer l’état d’une tâche. En règle générale, une expression lambda est utilisée pour spécifier le travail à effectuer la tâche.

Pour les opérations qui retournent des valeurs, vous utilisez la Task<TResult> classe.

Dans cette section :

Création et exécution d’une tâche
Séparation de l’exécution et la création de tâches
En attente d’une ou plusieurs tâches
Tâches et la culture
Pour les développeurs de débogueur

Task instances peuvent être créées de plusieurs façons. L’approche la plus courante, qui est disponible à partir du .NET Framework 4.5, consiste à appeler la méthode statique Run (méthode). Le Run méthode offre un moyen simple pour démarrer une tâche à l’aide des valeurs par défaut et sans nécessiter de paramètres supplémentaires. L’exemple suivant utilise le Run(Action) méthode pour lancer une tâche qui effectue une boucle, puis affiche le nombre d’itérations de boucle :

using System;
using System.Threading.Tasks;

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

Une alternative et la méthode la plus courante pour démarrer une tâche dans .NET Framework 4, est la méthode statique TaskFactory.StartNew (méthode). Le Task.Factory propriété retourne un TaskFactory objet. Les surcharges de la TaskFactory.StartNew méthode vous permettre de spécifier les paramètres à passer à un planificateur de tâches et les options de création de la tâche. L’exemple suivant utilise le TaskFactory.StartNew méthode pour démarrer une tâche. Il est fonctionnellement équivalent au code dans l’exemple précédent.

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

Pour des exemples plus complets, consultez Task Parallelism (Task Parallel Library).

La Task classe fournit également des constructeurs qui initialisent la tâche mais qui ne la planifient pas pour l’exécution. Pour des raisons de performances, le Task.Run ou TaskFactory.StartNew méthode est le mécanisme par défaut pour la création et la planification des tâches de calcul, mais pour les scénarios où la création et la planification doivent être séparés, vous pouvez utiliser les constructeurs et ensuite appeler la Task.Start méthode pour planifier la tâche pour l’exécution à un moment ultérieur.

Étant donné que les tâches sont généralement exécutent en mode asynchrone sur un 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. Dans certains cas, lorsque le thread appelant est le thread d’application principal, l’application peut se fermer avant tout la tâche commence l’exécution. Dans d’autres, 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. Vous pouvez synchroniser l’exécution du thread appelant et asynchrone de tâches qu’il démarre en appelant un Wait méthode d’attente d’une ou plusieurs tâches.

Pour attendre une tâche unique se termine, vous pouvez appeler son Task.Wait (méthode). Un appel à la Wait méthode bloque le thread appelant jusqu'à ce que l’instance de classe unique a terminé son exécution.

L’exemple suivant appelle sans paramètre Wait() méthode attendre sans condition une tâche se termine. La tâche simule le travail en appelant le Thread.Sleep méthode en veille pendant deux secondes.

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

Vous pouvez également conditionnelle attendre une tâche se termine. 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é, selon ce qui se produit en premier. É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 soit exécutée.

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.

Vous pouvez également fournir un jeton d’annulation en appelant le Wait(CancellationToken) et Wait(Int32, CancellationToken) méthodes. Si du jeton IsCancellationRequested propriété est true, l’attente est annulée ; si elle aura la valeur true lors de la Wait méthode se termine.

Dans certains cas, vous souhaiterez peut-être attendre pour le premier d’une série de l’exécution des tâches à effectuer, mais ne soins de tâches qu’il est. Pour cela, vous pouvez appeler une des surcharges de la Task.WaitAll méthode. L’exemple suivant crée trois tâches, chacune d’elles se met en veille pour un intervalle de déterminer par un générateur de nombres aléatoires. Le WaitAny(Task[]) méthode attend que la première tâche se termine. L’exemple affiche ensuite les informations sur l’état de tous les trois tâches.

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

Vous pouvez également attendre pour l’ensemble d’une série de tâches à effectuer en appelant le WaitAll (méthode). L’exemple suivant crée dix tâches, attend que toutes les dix terminer, puis affiche leur état.

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

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 la Wait méthode, comme le montre l’exemple suivant. Il lance des 12 tâches, dont trois se terminer normalement et trois des qui lèvent une exception. Les six tâches restantes, trois sont annulées avant le début de trois sont annulées lors de leur exécution. Les exceptions sont levées dans le WaitAll appel de méthode et sont gérées par un try/catch bloc.

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

Pour plus d’informations sur la gestion des exceptions dans les opérations asynchrones basées sur des tâches, consultez Gestion des exceptions (bibliothèque parallèle de tâches).

Démarrage avec les applications de bureau qui ciblent le .NET Framework 4.6, la culture du thread qui crée et appelle une tâche devient partie intégrante du contexte du thread. Autrement dit, indépendamment de la culture actuelle du thread sur lequel la tâche s’exécute, la culture en cours de la tâche est la culture du thread appelant. Pour les applications qui ciblent des versions du .NET Framework antérieures à la .NET Framework 4.6, la culture de la tâche est la culture du thread sur lequel la tâche s’exécute. Pour plus d’informations, consultez la section « Culture et opérations asynchrones basées sur une tâche » dans la CultureInfo rubrique.

System_CAPS_noteRemarque

Applications du Windows Store suivent le Windows Runtime dans la définition et l’obtention de la culture par défaut.

Pour les développeurs implémentent des débogueurs personnalisés, plusieurs membres internes et privés de tâche peuvent être utiles (ils peuvent varier d’une version à l’autre). 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 permet de récupérer le prochain ID disponible pour une tâche). De même, le m_stateFlags champ stocke des informations sur l’étape du cycle de vie actuel de la tâche, informations également accessibles via la Status propriété. 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. Enfin, pour les débogueurs qui analysent des frames de pile, le InternalWait méthode sert un marqueur potentiel pour une tâche entre lorsqu’une opération d’attente.

L’exemple suivant crée et exécute des quatre tâches. Trois tâches exécutent un Action<T> délégué nommé action, qui accepte un argument de 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. Chaque tâche est instanciée et exécution d’une manière différente :

  • Tâche t1 est instancié en appelant un constructeur de classe de tâche, mais est démarré en appelant son Start() méthode uniquement après la tâche t2 a démarré.

  • Tâche t2 est instancié et démarré dans un seul appel de méthode en appelant le TaskFactory.StartNew(Action<Object>, Object) (méthode).

  • Tâche t3 est instancié et démarré dans un seul appel de méthode en appelant le Run(Action) (méthode).

  • Tâche t4 est exécutée de façon synchrone sur le thread principal en appelant le RunSynchronously() (méthode).

Étant donné que tâche t4 exécute de façon synchrone, il s’exécute sur le thread d’application principal. Les tâches restantes exécutent de façon asynchrone en général sur un ou plusieurs threads du pool.

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 demonstate 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

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 4.0
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 5.0
Silverlight pour Windows Phone
Disponible depuis 8.0
Windows Phone
Disponible depuis 8.1

Tous les membres de Task, à l’exception de Dispose, sont thread-safe et peuvent être utilisés simultanément par plusieurs threads.

Retour au début
Afficher: