Task.Wait Task.Wait Task.Wait Task.Wait Method

Définition

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

Surcharges

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.

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(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() Wait() Wait() Wait()

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

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.

public:
 bool Wait(TimeSpan timeout);
public bool Wait (TimeSpan timeout);
member this.Wait : TimeSpan -> bool
Public Function Wait (timeout As TimeSpan) As Boolean

Paramètres

timeout
TimeSpan TimeSpan TimeSpan 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.A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.

Retours

true si l'exécution de Task s'est terminée dans le délai imparti ; sinon, false.true if the Task completed execution within the allotted time; otherwise, false.

Exceptions

timeout est un nombre négatif autre que -1 milliseconde, qui représente un délai d’attente infini.timeout is a negative number other than -1 milliseconds, which represents an infinite time-out. ou-or- timeout est supérieur à MaxValue.timeout is greater than MaxValue.

La tâche a été annulée.The task was canceled. La collection InnerExceptions contient un objet TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

ou-or- Une exception a été levée pendant l’exécution de la tâche.An exception was thrown during the execution of the task. La collection InnerExceptions contient des informations sur l’exception ou les exceptions.The InnerExceptions collection contains information about the exception or exceptions.

Exemples

L’exemple suivant démarre une tâche qui génère des entiers aléatoires de cinq millions comprise entre 0 et 100 et calcule leur moyenne.The following example starts a task that generates five million random integers between 0 and 100 and computes their mean. L’exemple utilise le Wait(TimeSpan) méthode pour attendre l’application terminée dans 150 millisecondes.The example uses the Wait(TimeSpan) method to wait for the application to complete within 150 milliseconds. Si l’application se termine normalement, la tâche affiche la somme et moyenne des nombres aléatoires qui il a généré.If the application completes normally, the task displays the sum and mean of the random numbers that it has generated. Si l’intervalle de délai d’expiration est écoulé, l’exemple affiche un message avant sa fermeture.If the timeout interval has elapsed, the example displays a message before it terminates.

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.
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run( Sub()
                                   Dim rnd As New Random()
                                   Dim sum As Long
                                   Dim n As Integer = 5000000
                                   For ctr As Integer = 1 To n
                                      Dim number As Integer = rnd.Next(0, 101)
                                      sum += number
                                   Next
                                   Console.WriteLine("Total:   {0:N0}", sum)
                                   Console.WriteLine("Mean:    {0:N2}", sum/n)
                                   Console.WriteLine("N:       {0:N0}", n)   
                                End Sub)
     Dim ts As TimeSpan = TimeSpan.FromMilliseconds(150)
     If Not t.Wait(ts) Then
        Console.WriteLine("The timeout interval elapsed.")
     End If
   End Sub
End Module
' 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 bloque le thread appelant à attendre pour l’instance actuelle de la tâche effectuer jusqu'à ce qu’une des actions suivantes se produit :Wait(TimeSpan) is a synchronization method that causes the calling thread to wait for the current task instance to complete until one of the following occurs:

  • La tâche se termine correctement.The task completes successfully.

  • La tâche elle-même est annulée ou lève une exception.The task itself is canceled or throws an exception. Dans ce cas, vous gérez un AggregateException exception.In this case, you handle an AggregateException exception. Le AggregateException.InnerExceptions propriété contient des détails sur l’exception ou les exceptions.The AggregateException.InnerExceptions property contains details about the exception or exceptions.

  • L’intervalle défini par timeout s’écoule.The interval defined by timeout elapses. Dans ce cas, le thread actuel reprend l’exécution et la méthode retourne false.In this case, the current thread resumes execution and the method returns false.

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.

public:
 bool Wait(int millisecondsTimeout, System::Threading::CancellationToken cancellationToken);
public bool Wait (int millisecondsTimeout, System.Threading.CancellationToken cancellationToken);
member this.Wait : int * System.Threading.CancellationToken -> bool

Paramètres

millisecondsTimeout
Int32 Int32 Int32 Int32

Nombre de millisecondes à attendre, ou Infinite (-1) pour un délai d'attente infini.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Jeton d’annulation à observer en attendant que la tâche se termine.A cancellation token to observe while waiting for the task to complete.

Retours

true si l'exécution de Task s'est terminée dans le délai imparti ; sinon, false.true if the Task completed execution within the allotted time; otherwise, false.

Exceptions

cancellationToken a été annulé.The cancellationToken was canceled.

millisecondsTimeout est un nombre négatif différent de -1, qui représente un délai d’attente infini.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

La tâche a été annulée.The task was canceled. La collection InnerExceptions contient un objet TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

ou-or- Une exception a été levée pendant l’exécution de la tâche.An exception was thrown during the execution of the task. La collection InnerExceptions contient des informations sur l’exception ou les exceptions.The InnerExceptions collection contains information about the exception or exceptions.

Exemples

L’exemple suivant appelle la Wait(Int32, CancellationToken) méthode pour fournir une valeur de délai d’attente et une annulation de jeton qui peut se terminer l’attente de fin d’une tâche.The following example calls the Wait(Int32, CancellationToken) method to provide both a timeout value and a cancellation token that can end the wait for a task's completion. Un nouveau thread est démarré et qu’il exécute le CancelToken (méthode), qui met en pause et appelle ensuite la CancellationTokenSource.Cancel méthode pour annuler les jetons d’annulation.A new thread is started and executes the CancelToken method, which pauses and then calls the CancellationTokenSource.Cancel method to cancel the cancellation tokens. Une tâche est alors lancée et retarde pendant 5 secondes.A task is then launched and delays for 5 seconds. Le Wait méthode est ensuite appelée pour attendre la fin de la tâche et n’est fournie à la fois un bref délai et un jeton d’annulation.The Wait method is then called to wait for the task's completion and is provided both a brief timeout value and a cancellation token.

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...
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim ts As New CancellationTokenSource()
      Dim thread As New Thread(AddressOf CancelToken)
      thread.Start(ts)

      Dim t As Task = Task.Run( Sub()
                                   Task.Delay(5000).Wait()
                                    Console.WriteLine("Task ended delay...")
                                End Sub)
      Try
         Console.WriteLine("About to wait completion of task {0}", t.Id)
         Dim result As Boolean = t.Wait(1510, ts.Token)
         Console.WriteLine("Wait completed normally: {0}", result)
         Console.WriteLine("The task status:  {0:G}", t.Status)
      Catch e As OperationCanceledException
         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()
      End Try
   End Sub

   Private Sub CancelToken(obj As Object)
      Thread.Sleep(1500)
      Console.WriteLine("Canceling the cancellation token from thread {0}...",
                        Thread.CurrentThread.ManagedThreadId)

      If TypeOf obj Is CancellationTokenSource Then
         Dim source As CancellationTokenSource = CType(obj, CancellationTokenSource)
         source.Cancel()
      End If
   End Sub
End Module
' 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 à partir de l’exemple dépend de si l’attente a été annulée en raison du jeton d’annulation ou parce que l’intervalle de délai d’expiration est écoulé.Note that the precise output from the example depends on whether the wait was canceled because of the cancellation token or because the timeout interval elapsed.

Remarques

Wait(Int32, CancellationToken) est une méthode de synchronisation qui bloque le thread appelant à attendre pour l’instance actuelle de la tâche effectuer jusqu'à ce qu’une des actions suivantes se produit :Wait(Int32, CancellationToken) is a synchronization method that causes the calling thread to wait for the current task instance to complete until one of the following occurs:

  • La tâche se termine correctement.The task completes successfully.

  • La tâche elle-même est annulée ou lève une exception.The task itself is canceled or throws an exception. Dans ce cas, vous gérez un AggregateException exception.In this case, you handle an AggregateException exception. Le AggregateException.InnerExceptions propriété contient des détails sur l’exception ou les exceptions.The AggregateException.InnerExceptions property contains details about the exception or exceptions.

  • Le cancellationToken jeton d’annulation est annulé.The cancellationToken cancellation token is canceled. Dans ce cas, l’appel à la Wait(Int32, CancellationToken) méthode lève un OperationCanceledException.In this case, the call to the Wait(Int32, CancellationToken) method throws an OperationCanceledException.

  • L’intervalle défini par millisecondsTimeout s’écoule.The interval defined by millisecondsTimeout elapses. Dans ce cas, le thread actuel reprend l’exécution et la méthode retourne false.In this case, the current thread resumes execution and the method returns false.

Notes

Annulation de la cancellationToken jeton d’annulation n’a aucun effet sur la tâche en cours d’exécution, sauf si elle a également été le jeton d’annulation passé et est prêt à gérer l’annulation.Canceling the cancellationToken cancellation token has no effect on the running task unless it has also been passed the cancellation token and is prepared to handle cancellation. En passant le cancellationToken objet à cette méthode permet simplement l’attente d’être annulée en fonction de certaines conditions.Passing the cancellationToken object to this method simply allows the wait to be canceled based on some condition.

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.

public:
 void Wait(System::Threading::CancellationToken cancellationToken);
public void Wait (System.Threading.CancellationToken cancellationToken);
member this.Wait : System.Threading.CancellationToken -> unit

Paramètres

cancellationToken
CancellationToken CancellationToken CancellationToken CancellationToken

Jeton d’annulation à observer en attendant que la tâche se termine.A cancellation token to observe while waiting for the task to complete.

Exceptions

cancellationToken a été annulé.The cancellationToken was canceled.

La tâche a été supprimée.The task has been disposed.

La tâche a été annulée.The task was canceled. La collection InnerExceptions contient un objet TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

ou-or- Une exception a été levée pendant l’exécution de la tâche.An exception was thrown during the execution of the task. La collection InnerExceptions contient des informations sur l’exception ou les exceptions.The InnerExceptions collection contains information about the exception or exceptions.

Exemples

L’exemple suivant illustre l’utilisation d’un jeton d’annulation pour annuler l’attente de fin d’une tâche simple.The following example illustrates the simple use of a cancellation token to cancel waiting for a task's completion. Une tâche est lancée, appelle le CancellationTokenSource.Cancel méthode pour annuler toute la source de jeton jetons d’annulation, puis des retards pendant cinq secondes.A task is launched, calls the CancellationTokenSource.Cancel method to cancel any of the token source's cancellation tokens, and then delays for five seconds. Notez que la tâche proprement dite n’a pas été passée le jeton d’annulation et s’il n’est pas annulable.Note that the task itself has not been passed the cancellation token and is not cancelable. Le thread d’application appelle la tâche Task.Wait méthode pour attendre la tâche se termine, mais que l’attente est annulée une fois que le jeton d’annulation est annulé et qu’un OperationCanceledException est levée.The application thread calls the task's Task.Wait method to wait for the task to complete, but the wait is canceled once the cancellation token is cancelled and an OperationCanceledException is thrown. Le Gestionnaire d’exceptions signale l’exception et puis se met en veille pendant six secondes.The exception handler reports the exception and then sleeps for six seconds. Comme le montre la sortie de l’exemple, ce délai permet à la tâche se termine dans le RanToCompletion état.As the output from the example shows, that delay allows the task to complete in the RanToCompletion state.

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
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim ts As New CancellationTokenSource()

      Dim t = Task.Run( Sub()
                           Console.WriteLine("Calling Cancel...")
                           ts.Cancel()
                           Task.Delay(5000).Wait()
                           Console.WriteLine("Task ended delay...")
                        End Sub)
      Try
         Console.WriteLine("About to wait for the task to complete...")
         t.Wait(ts.Token)
      Catch e As OperationCanceledException
         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)
      End Try
      ts.Dispose()
   End Sub
End Module
' 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

Le Wait(CancellationToken) méthode crée une attente annulable ; autrement dit, il oblige le thread actuel attendre qu’une des actions suivantes se produit :The Wait(CancellationToken) method creates a cancelable wait; that is, it causes the current thread to wait until one of the following occurs:

Notes

Annulation de la cancellationToken jeton d’annulation n’a aucun effet sur la tâche en cours d’exécution, sauf si elle a également été le jeton d’annulation passé et est prêt à gérer l’annulation.Canceling the cancellationToken cancellation token has no effect on the running task unless it has also been passed the cancellation token and is prepared to handle cancellation. En passant le cancellationToken objet à cette méthode permet simplement de l’attente d’être annulée.Passing the cancellationToken object to this method simply allows the wait to be canceled.

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.

public:
 bool Wait(int millisecondsTimeout);
public bool Wait (int millisecondsTimeout);
member this.Wait : int -> bool
Public Function Wait (millisecondsTimeout As Integer) As Boolean

Paramètres

millisecondsTimeout
Int32 Int32 Int32 Int32

Nombre de millisecondes à attendre, ou Infinite (-1) pour un délai d'attente infini.The number of milliseconds to wait, or Infinite (-1) to wait indefinitely.

Retours

true si l'exécution de Task s'est terminée dans le délai imparti ; sinon, false.true if the Task completed execution within the allotted time; otherwise, false.

Exceptions

millisecondsTimeout est un nombre négatif différent de -1, qui représente un délai d’attente infini.millisecondsTimeout is a negative number other than -1, which represents an infinite time-out.

La tâche a été annulée.The task was canceled. La collection InnerExceptions contient un objet TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

ou-or- Une exception a été levée pendant l’exécution de la tâche.An exception was thrown during the execution of the task. La collection InnerExceptions contient des informations sur l’exception ou les exceptions.The InnerExceptions collection contains information about the exception or exceptions.

Exemples

L’exemple suivant démarre une tâche qui génère des entiers aléatoires de cinq millions comprise entre 0 et 100 et calcule leur moyenne.The following example starts a task that generates five million random integers between 0 and 100 and computes their mean. L’exemple utilise le Wait(Int32) méthode pour attendre l’application terminée dans 150 millisecondes.The example uses the Wait(Int32) method to wait for the application to complete within 150 milliseconds. Si l’application se termine normalement, la tâche affiche la somme et moyenne des nombres aléatoires qui il a généré.If the application completes normally, the task displays the sum and mean of the random numbers that it has generated. Si l’intervalle de délai d’expiration est écoulé, l’exemple affiche un message avant sa fermeture.If the timeout interval has elapsed, the example displays a message before it terminates.

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.
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run( Sub()
                                   Dim rnd As New Random()
                                   Dim sum As Long
                                   Dim n As Integer = 5000000
                                   For ctr As Integer = 1 To n
                                      Dim number As Integer = rnd.Next(0, 101)
                                      sum += number
                                   Next
                                   Console.WriteLine("Total:   {0:N0}", sum)
                                   Console.WriteLine("Mean:    {0:N2}", sum/n)
                                   Console.WriteLine("N:       {0:N0}", n)   
                                End Sub)
     If Not t.Wait(150) Then
        Console.WriteLine("The timeout interval elapsed.")
     End If
   End Sub
End Module
' 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 bloque le thread appelant à attendre pour l’instance actuelle de la tâche effectuer jusqu'à ce qu’une des actions suivantes se produit :Wait(Int32) is a synchronization method that causes the calling thread to wait for the current task instance to complete until one of the following occurs:

  • La tâche se termine correctement.The task completes successfully.

  • La tâche elle-même est annulée ou lève une exception.The task itself is canceled or throws an exception. Dans ce cas, vous gérez un AggregateException exception.In this case, you handle an AggregateException exception. Le AggregateException.InnerExceptions propriété contient des détails sur l’exception ou les exceptions.The AggregateException.InnerExceptions property contains details about the exception or exceptions.

  • L’intervalle défini par millisecondsTimeout s’écoule.The interval defined by millisecondsTimeout elapses. Dans ce cas, le thread actuel reprend l’exécution et la méthode retourne false.In this case, the current thread resumes execution and the method returns false.

Wait() Wait() Wait() Wait()

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

public:
 void Wait();
public void Wait ();
member this.Wait : unit -> unit
Public Sub Wait ()

Exceptions

La tâche a été annulée.The task was canceled. La collection InnerExceptions contient un objet TaskCanceledException.The InnerExceptions collection contains a TaskCanceledException object.

ou-or- Une exception a été levée pendant l’exécution de la tâche.An exception was thrown during the execution of the task. La collection InnerExceptions contient des informations sur l’exception ou les exceptions.The InnerExceptions collection contains information about the exception or 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.The following example starts a task that generates one million random integers between 0 and 100 and computes their mean. L’exemple utilise le Wait pour s’assurer que la tâche se termine avant que l’application se termine.The example uses the Wait method to ensure that the task completes before the application terminates. Sinon, car il s’agit d’une application console, l’exemple se terminerait avant que la tâche peut calculer et afficher la moyenne.Otherwise, because this is a console application, the example would terminate before the task can compute and display the mean.

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
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim t As Task = Task.Run( Sub()
                                   Dim rnd As New Random()
                                   Dim sum As Long
                                   Dim n As Integer = 1000000
                                   For ctr As Integer = 1 To n
                                      Dim number As Integer = rnd.Next(0, 101)
                                      sum += number
                                   Next
                                   Console.WriteLine("Total:   {0:N0}", sum)
                                   Console.WriteLine("Mean:    {0:N2}", sum/n)
                                   Console.WriteLine("N:       {0:N0}", n)   
                                End Sub)
     t.Wait()
   End Sub
End Module
' 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 bloque le thread appelant à attendre la fin de la tâche en cours.Wait is a synchronization method that causes the calling thread to wait until the current task has completed. Si la tâche en cours n’a pas démarré l’exécution, la méthode Wait tente de supprimer la tâche du planificateur et exécutez-la inline sur le thread actuel.If the current task has not started execution, the Wait method attempts to remove the task from the scheduler and execute it inline on the current thread. S’il est impossible pour ce faire, ou si la tâche en cours a déjà démarré l’exécution, elle bloque le thread appelant jusqu'à ce que la tâche se termine.If it is unable to do that, or if the current task has already started execution, it blocks the calling thread until the task completes. Pour plus d’informations, consultez Task.Wait et la fonctionnalité « inline » dans le blog programmation parallèle avec .NET.For more information, see Task.Wait and "Inlining" in the Parallel Programming with .NET blog.

Voir aussi

S’applique à