Task.Wait Méthode

Définition

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

Surcharges

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)

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)

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)

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

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

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

Task a été supprimé.The Task has been disposed.

timeout est un nombre négatif différent de -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 5 millions 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 la méthode Wait(TimeSpan) pour attendre que l’application se termine dans un délai de 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 la moyenne des nombres aléatoires qu’elle a générés.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’attente est écoulé, l’exemple affiche un message avant qu’il ne se termine.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 oblige le thread appelant à attendre la fin de l’exécution de l’instance de tâche actuelle jusqu’à ce que l’un des éléments suivants se produise :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 une exception AggregateException.In this case, you handle an AggregateException exception. La propriété AggregateException.InnerExceptions 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)

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

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

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.

Task a été supprimé.The Task has been disposed.

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 méthode Wait(Int32, CancellationToken) pour fournir une valeur de délai d’attente et un jeton d’annulation qui peuvent mettre fin à l’attente de l’achèvement 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 exécute la méthode CancelToken, qui s’interrompt, puis appelle la méthode CancellationTokenSource.Cancel 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 ensuite lancée et retarde de 5 secondes.A task is then launched and delays for 5 seconds. La méthode Wait est ensuite appelée pour attendre la fin de la tâche et est fournie à la fois une valeur de délai d’expiration courte 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 de l’exemple varie selon que l’attente a été annulée en raison du jeton d’annulation ou parce que l’intervalle de délai d’attente s’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 oblige le thread appelant à attendre la fin de l’exécution de l’instance de tâche actuelle jusqu’à ce que l’un des éléments suivants se produise :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 une exception AggregateException.In this case, you handle an AggregateException exception. La propriété AggregateException.InnerExceptions contient des détails sur l’exception ou les exceptions.The AggregateException.InnerExceptions property contains details about the exception or exceptions.

  • Le jeton d’annulation cancellationToken est annulé.The cancellationToken cancellation token is canceled. Dans ce cas, l’appel à la méthode Wait(Int32, CancellationToken) lève une 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

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 lui a également été passé et s’il 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. Le passage de l’objet cancellationToken à cette méthode permet simplement à l’attente d’être annulée en fonction d’une condition.Passing the cancellationToken object to this method simply allows the wait to be canceled based on some condition.

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

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 simple d’un jeton d’annulation pour annuler l’attente de l’achèvement d’une tâche.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 la méthode CancellationTokenSource.Cancel pour annuler les jetons d’annulation de la source du jeton, puis retarde 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 elle-même n’a pas été passée au jeton d’annulation et qu’elle 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 méthode Task.Wait de 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’une 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, 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 de se terminer dans l’État RanToCompletion.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

La méthode Wait(CancellationToken) crée une attente annulable ; autrement dit, le thread actuel attend que l’un des éléments suivants se produise :The Wait(CancellationToken) method creates a cancelable wait; that is, it causes the current thread to wait until one of the following occurs:

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 lui a également été passé et s’il 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. Le passage de l’objet cancellationToken à cette méthode permet simplement à l’attente d’être annulée.Passing the cancellationToken object to this method simply allows the wait to be canceled.

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

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

Task a été supprimé.The Task has been disposed.

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 5 millions 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 la méthode Wait(Int32) pour attendre que l’application se termine dans un délai de 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 la moyenne des nombres aléatoires qu’elle a générés.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’attente est écoulé, l’exemple affiche un message avant qu’il ne se termine.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 oblige le thread appelant à attendre la fin de l’exécution de l’instance de tâche actuelle jusqu’à ce que l’un des éléments suivants se produise :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 une exception AggregateException.In this case, you handle an AggregateException exception. La propriété AggregateException.InnerExceptions 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()

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

Task a été supprimé.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 démarre une tâche qui génère des entiers aléatoires 1 million 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 la méthode Wait pour s’assurer que la tâche se termine avant la fin de l’application.The example uses the Wait method to ensure that the task completes before the application terminates. Dans le cas contraire, comme il s’agit d’une application console, l’exemple se termine avant que la tâche puisse 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 oblige 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 l’exécution de la tâche actuelle n’a pas démarré, la méthode Wait tente de supprimer la tâche du planificateur et de l’exécuter 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 n’y parvient pas, 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 « Inline » dans le blog Parallel Programming with .net (en anglais).For more information, see Task.Wait and "Inlining" in the Parallel Programming with .NET blog.

Voir aussi

S’applique à