Task.Wait Méthode

Définition

Espace de noms:

System.Threading.Tasks

Assembly:

System.Runtime.dll

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

Surcharges

Wait(TimeSpan, CancellationToken)	Attend la fin de l'exécution de Task.
Wait(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.
Wait(TimeSpan)	Attend la fin de l'exécution de la Task dans un intervalle de temps spécifié.
Wait(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.
Wait()	Attend la fin de l'exécution de Task.
Wait(Int32)	Attend la fin de l'exécution de la Task en un nombre de millisecondes spécifié.

Wait(TimeSpan, CancellationToken)

Source:

Task.cs

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

C#

public bool Wait (TimeSpan timeout, System.Threading.CancellationToken cancellationToken);

Paramètres

timeout

TimeSpan

Le temps d’attendre ou InfiniteTimeSpan d’attendre indéfiniment

cancellationToken

CancellationToken

CancellationToken À observer en attendant la fin de la tâche.

Retours

Boolean

true si l'exécution de Task s'est terminée dans le délai imparti ; sinon, false.

Exceptions

AggregateException

A Task été annulé

-ou-

une exception a été levée pendant l’exécution de .Task

ArgumentOutOfRangeException

timeout est un nombre négatif autre que -1 millisecondes, qui représente un délai d’attente infini

-ou-

le délai d’expiration est supérieur à MaxValue.

OperationCanceledException

cancellationToken a été annulé.

Wait(Int32, CancellationToken)

Source:

Task.cs

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.

C#

public bool Wait (int millisecondsTimeout, System.Threading.CancellationToken cancellationToken);

Paramètres

millisecondsTimeout

Int32

Nombre de millisecondes à attendre, ou Infinite (-1) pour un délai d'attente infini.

cancellationToken

CancellationToken

Jeton d’annulation à observer en attendant que la tâche se termine.

Retours

Boolean

true si l'exécution de Task s'est terminée dans le délai imparti ; sinon, false.

Exceptions

OperationCanceledException

cancellationToken a été annulé.

ObjectDisposedException

Task a été supprimé.

ArgumentOutOfRangeException

millisecondsTimeout est un nombre négatif différent de -1, qui représente un délai d’attente infini.

AggregateException

La tâche a été annulée. La collection InnerExceptions contient un objet TaskCanceledException.

- ou -

Une exception a été levée pendant l’exécution de la tâche. La collection InnerExceptions contient des informations sur l’exception ou les exceptions.

Exemples

L’exemple suivant appelle la méthode pour fournir à la Wait(Int32, CancellationToken) fois une valeur de délai d’expiration et un jeton d’annulation qui peut mettre fin à l’attente de l’achèvement d’une tâche. Un nouveau thread est démarré et exécute la CancelToken méthode, qui interrompt puis appelle la CancellationTokenSource.Cancel méthode pour annuler les jetons d’annulation. Une tâche est ensuite lancée et retardée pendant 5 secondes. La Wait méthode est ensuite appelée pour attendre l’achèvement de la tâche et est fournie à la fois une valeur de délai d’expiration brève et un jeton d’annulation.

C#

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

public class Example
{
   public static void Main()
   {
      CancellationTokenSource ts = new CancellationTokenSource();
      Thread thread = new Thread(CancelToken);
      thread.Start(ts);

      Task t = Task.Run( () => { Task.Delay(5000).Wait();
                                 Console.WriteLine("Task ended delay...");
                               });
      try {
         Console.WriteLine("About to wait completion of task {0}", t.Id);
         bool result = t.Wait(1510, ts.Token);
         Console.WriteLine("Wait completed normally: {0}", result);
         Console.WriteLine("The task status:  {0:G}", t.Status);
      }
      catch (OperationCanceledException e) {
         Console.WriteLine("{0}: The wait has been canceled. Task status: {1:G}",
                           e.GetType().Name, t.Status);
         Thread.Sleep(4000);
         Console.WriteLine("After sleeping, the task status:  {0:G}", t.Status);
         ts.Dispose();
      }
   }

   private static void CancelToken(Object obj)
   {
      Thread.Sleep(1500);
      Console.WriteLine("Canceling the cancellation token from thread {0}...",
                        Thread.CurrentThread.ManagedThreadId);
      CancellationTokenSource source = obj as CancellationTokenSource;
      if (source != null) source.Cancel();
   }
}
// The example displays output like the following if the wait is canceled by
// the cancellation token:
//    About to wait completion of task 1
//    Canceling the cancellation token from thread 3...
//    OperationCanceledException: The wait has been canceled. Task status: Running
//    Task ended delay...
//    After sleeping, the task status:  RanToCompletion
// The example displays output like the following if the wait is canceled by
// the timeout interval expiring:
//    About to wait completion of task 1
//    Wait completed normally: False
//    The task status:  Running
//    Canceling the cancellation token from thread 3...

Notez que la sortie précise de l’exemple dépend si l’attente a été annulée en raison du jeton d’annulation ou du fait que l’intervalle de délai d’attente s’est écoulé.

Remarques

Wait(Int32, CancellationToken)est une méthode de synchronisation qui oblige le thread appelant à attendre que la tâche actuelle instance se termine jusqu’à ce que l’un des éléments suivants se produise :

• La tâche se termine correctement.

• La tâche elle-même est annulée ou lève une exception. Dans ce cas, vous gérez une AggregateException exception. La AggregateException.InnerExceptions propriété contient des détails sur l’exception ou les exceptions.

• Le cancellationToken jeton d’annulation est annulé. Dans ce cas, l’appel à la Wait(Int32, CancellationToken) méthode lève un OperationCanceledException.

• Intervalle défini par millisecondsTimeout les intervalles. Dans ce cas, le thread actuel reprend l’exécution et la méthode retourne false.

Notes

L’annulation du cancellationToken jeton d’annulation n’a aucun effet sur la tâche en cours d’exécution, sauf si le jeton d’annulation a également été transmis et qu’il est prêt à gérer l’annulation. Le passage de l’objet cancellationToken à cette méthode permet simplement d’annuler l’attente en fonction d’une condition.

Wait(TimeSpan)

Source:

Task.cs

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

C#

public bool Wait (TimeSpan timeout);

Paramètres

timeout

TimeSpan

TimeSpan qui représente le nombre de millièmes de secondes à attendre ou TimeSpan qui représente -1 millième de seconde, pour attendre indéfiniment.

Retours

Boolean

true si l'exécution de Task s'est terminée dans le délai imparti ; sinon, false.

Exceptions

ObjectDisposedException

Task a été supprimé.

ArgumentOutOfRangeException

timeout est un nombre négatif différent de -1 milliseconde, qui représente un délai d’attente infini.

-ou-

timeout est supérieur à Int32.MaxValue.

AggregateException

La tâche a été annulée. La collection InnerExceptions contient un objet TaskCanceledException.

- ou -

Une exception a été levée pendant l’exécution de la tâche. La collection InnerExceptions contient des informations sur l’exception ou les exceptions.

Exemples

L’exemple suivant démarre une tâche qui génère cinq millions d’entiers aléatoires compris entre 0 et 100 et calcule leur moyenne. L’exemple utilise la Wait(TimeSpan) méthode pour attendre que l’application se termine dans un délai de 150 millisecondes. Si l’application se termine normalement, la tâche affiche la somme et la moyenne des nombres aléatoires qu’elle a générés. Si l’intervalle de délai d’expiration s’est écoulé, l’exemple montre comment afficher un message avant qu’il ne se termine.

C#

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Run( () => {
                            Random rnd = new Random();
                            long sum = 0;
                            int n = 5000000;
                            for (int ctr = 1; ctr <= n; ctr++) {
                               int number = rnd.Next(0, 101);
                               sum += number;
                            }
                            Console.WriteLine("Total:   {0:N0}", sum);
                            Console.WriteLine("Mean:    {0:N2}", sum/n);
                            Console.WriteLine("N:       {0:N0}", n);   
                         } );
     TimeSpan ts = TimeSpan.FromMilliseconds(150);
     if (! t.Wait(ts))
        Console.WriteLine("The timeout interval elapsed.");
   }
}
// The example displays output similar to the following:
//       Total:   50,015,714
//       Mean:    50.02
//       N:       1,000,000
// Or it displays the following output:
//      The timeout interval elapsed.

Remarques

Wait(TimeSpan)est une méthode de synchronisation qui oblige le thread appelant à attendre que la tâche actuelle instance se termine jusqu’à ce que l’un des éléments suivants se produise :

• La tâche se termine correctement.

• La tâche elle-même est annulée ou lève une exception. Dans ce cas, vous gérez une AggregateException exception. La AggregateException.InnerExceptions propriété contient des détails sur l’exception ou les exceptions.

• Intervalle défini par timeout les intervalles. Dans ce cas, le thread actuel reprend l’exécution et la méthode retourne false.

Wait(CancellationToken)

Source:

Task.cs

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.

C#

public void Wait (System.Threading.CancellationToken cancellationToken);

Paramètres

cancellationToken

CancellationToken

Jeton d’annulation à observer en attendant que la tâche se termine.

Exceptions

OperationCanceledException

cancellationToken a été annulé.

ObjectDisposedException

La tâche a été supprimée.

AggregateException

La tâche a été annulée. La collection InnerExceptions contient un objet TaskCanceledException.

- ou -

Une exception a été levée pendant l’exécution de la tâche. La collection InnerExceptions contient des informations sur l’exception ou les exceptions.

Exemples

L’exemple suivant illustre l’utilisation simple d’un jeton d’annulation pour annuler l’attente de l’achèvement d’une tâche. Une tâche est lancée, appelle la CancellationTokenSource.Cancel méthode pour annuler les jetons d’annulation de la source de jeton, puis retarde pendant cinq secondes. Notez que la tâche elle-même n’a pas reçu le jeton d’annulation et n’est pas annulable. Le thread d’application appelle la méthode de Task.Wait la tâche pour attendre la fin de la tâche, mais l’attente est annulée une fois que le jeton d’annulation est annulé et qu’un OperationCanceledException est levée. Le gestionnaire d’exceptions signale l’exception, puis se met en veille pendant six secondes. Comme le montre la sortie de l’exemple, ce délai permet à la tâche de se terminer dans l’état RanToCompletion .

C#

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

public class Example
{
   public static void Main()
   {
      CancellationTokenSource ts = new CancellationTokenSource();

      Task t = Task.Run( () => { Console.WriteLine("Calling Cancel...");
                                 ts.Cancel();
                                 Task.Delay(5000).Wait();
                                 Console.WriteLine("Task ended delay...");
                               });
      try {
         Console.WriteLine("About to wait for the task to complete...");
         t.Wait(ts.Token);
      }
      catch (OperationCanceledException e) {
         Console.WriteLine("{0}: The wait has been canceled. Task status: {1:G}",
                           e.GetType().Name, t.Status);
         Thread.Sleep(6000);
         Console.WriteLine("After sleeping, the task status:  {0:G}", t.Status);
      }
      ts.Dispose();
   }
}
// The example displays output like the following:
//    About to wait for the task to complete...
//    Calling Cancel...
//    OperationCanceledException: The wait has been canceled. Task status: Running
//    Task ended delay...
//    After sleeping, the task status:  RanToCompletion

Remarques

La Wait(CancellationToken) méthode crée une attente annulable, c’est-à-dire qu’elle entraîne l’attente du thread actuel jusqu’à ce que l’un des éléments suivants se produise :

• La tâche se termine.

• Le jeton d’annulation est annulé. Dans ce cas, l’appel à la Wait(CancellationToken) méthode lève un OperationCanceledException.

Notes

L’annulation du cancellationToken jeton d’annulation n’a aucun effet sur la tâche en cours d’exécution, sauf si le jeton d’annulation a également été transmis et qu’il est prêt à gérer l’annulation. Le passage de l’objet cancellationToken à cette méthode permet simplement d’annuler l’attente.

Wait()

Source:

Task.cs

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

C#

public void Wait ();

Exceptions

ObjectDisposedException

Task a été supprimé.

AggregateException

La tâche a été annulée. La collection InnerExceptions contient un objet TaskCanceledException.

- ou -

Une exception a été levée pendant l’exécution de la tâche. La collection InnerExceptions contient des informations sur l’exception ou les exceptions.

Exemples

L’exemple suivant démarre une tâche qui génère un million d’entiers aléatoires compris entre 0 et 100 et calcule leur moyenne. L’exemple utilise la Wait méthode pour s’assurer que la tâche se termine avant la fin de l’application. Sinon, comme il s’agit d’une application console, l’exemple se terminerait avant que la tâche puisse calculer et afficher la moyenne.

C#

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Run( () => {
                            Random rnd = new Random();
                            long sum = 0;
                            int n = 1000000;
                            for (int ctr = 1; ctr <= n; ctr++) {
                               int number = rnd.Next(0, 101);
                               sum += number;
                            }
                            Console.WriteLine("Total:   {0:N0}", sum);
                            Console.WriteLine("Mean:    {0:N2}", sum/n);
                            Console.WriteLine("N:       {0:N0}", n);   
                         } );
     t.Wait();
   }
}
// The example displays output similar to the following:
//       Total:   50,015,714
//       Mean:    50.02
//       N:       1,000,000

Remarques

Wait est une méthode de synchronisation qui fait attendre le thread appelant jusqu’à ce que la tâche actuelle soit terminée. Si la tâche actuelle n’a pas démarré l’exécution, la méthode Wait tente de supprimer la tâche du planificateur et de l’exécuter en ligne sur le thread actuel. S’il ne parvient pas à le faire, ou si l’exécution de la tâche actuelle a déjà commencé, il bloque le thread appelant jusqu’à ce que la tâche se termine. Pour plus d’informations, consultez Task.Wait et « Inlining » dans le blog Programmation parallèle avec .NET.

Voir aussi

• Task.Wait et « Inlining »

Wait(Int32)

Source:

Task.cs

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

C#

public bool Wait (int millisecondsTimeout);

Paramètres

millisecondsTimeout

Int32

Nombre de millisecondes à attendre, ou Infinite (-1) pour un délai d'attente infini.

Retours

Boolean

true si l'exécution de Task s'est terminée dans le délai imparti ; sinon, false.

Exceptions

ObjectDisposedException

Task a été supprimé.

ArgumentOutOfRangeException

millisecondsTimeout est un nombre négatif différent de -1, qui représente un délai d’attente infini.

AggregateException

La tâche a été annulée. La collection InnerExceptions contient un objet TaskCanceledException.

- ou -

Une exception a été levée pendant l’exécution de la tâche. La collection InnerExceptions contient des informations sur l’exception ou les exceptions.

Exemples

L’exemple suivant démarre une tâche qui génère cinq millions d’entiers aléatoires compris entre 0 et 100 et calcule leur moyenne. L’exemple utilise la Wait(Int32) méthode pour attendre que l’application se termine dans un délai de 150 millisecondes. Si l’application se termine normalement, la tâche affiche la somme et la moyenne des nombres aléatoires qu’elle a générés. Si l’intervalle de délai d’expiration s’est écoulé, l’exemple montre comment afficher un message avant qu’il ne se termine.

C#

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Task t = Task.Run( () => {
                            Random rnd = new Random();
                            long sum = 0;
                            int n = 5000000;
                            for (int ctr = 1; ctr <= n; ctr++) {
                               int number = rnd.Next(0, 101);
                               sum += number;
                            }
                            Console.WriteLine("Total:   {0:N0}", sum);
                            Console.WriteLine("Mean:    {0:N2}", sum/n);
                            Console.WriteLine("N:       {0:N0}", n);   
                         } );
     if (! t.Wait(150))
        Console.WriteLine("The timeout interval elapsed.");
   }
}
// The example displays output similar to the following:
//       Total:   50,015,714
//       Mean:    50.02
//       N:       1,000,000
// Or it displays the following output:
//      The timeout interval elapsed.

Remarques

Wait(Int32)est une méthode de synchronisation qui oblige le thread appelant à attendre que la tâche actuelle instance se termine jusqu’à ce que l’une des opérations suivantes se produise :

• La tâche se termine correctement.

• La tâche elle-même est annulée ou lève une exception. Dans ce cas, vous gérez une AggregateException exception. La AggregateException.InnerExceptions propriété contient des détails sur l’exception ou les exceptions.

• Intervalle défini par millisecondsTimeout s’écoule. Dans ce cas, le thread actuel reprend l’exécution et la méthode retourne false.