Task.WhenAll Task.WhenAll Task.WhenAll Task.WhenAll Method

Définition

Crée une tâche qui s'achève lorsque toutes les tâches fournies sont terminées.Creates a task that will complete when all of the supplied tasks have completed.

Surcharges

WhenAll(IEnumerable<Task>) WhenAll(IEnumerable<Task>) WhenAll(IEnumerable<Task>) WhenAll(IEnumerable<Task>)

Crée une tâche qui s’achève quand tous les objets Task d’une collection énumérable sont terminés.Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[])

Crée une tâche qui s’achève quand tous les objets Task d’un tableau sont terminés.Creates a task that will complete when all of the Task objects in an array have completed.

WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>)

Crée une tâche qui s’achève quand tous les objets Task<TResult> d’une collection énumérable sont terminés.Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

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

Crée une tâche qui s’achève quand tous les objets Task<TResult> d’un tableau sont terminés.Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

WhenAll(IEnumerable<Task>) WhenAll(IEnumerable<Task>) WhenAll(IEnumerable<Task>) WhenAll(IEnumerable<Task>)

Crée une tâche qui s’achève quand tous les objets Task d’une collection énumérable sont terminés.Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

public:
 static System::Threading::Tasks::Task ^ WhenAll(System::Collections::Generic::IEnumerable<System::Threading::Tasks::Task ^> ^ tasks);
public static System.Threading.Tasks.Task WhenAll (System.Collections.Generic.IEnumerable<System.Threading.Tasks.Task> tasks);
static member WhenAll : seq<System.Threading.Tasks.Task> -> System.Threading.Tasks.Task
Public Shared Function WhenAll (tasks As IEnumerable(Of Task)) As Task

Paramètres

tasks
IEnumerable<Task>

Tâches restantes à exécuter avant la fin.The tasks to wait on for completion.

Retours

Tâche qui représente l'achèvement de toutes les tâches fournies.A task that represents the completion of all of the supplied tasks.

Exceptions

L'argument tasks était null.The tasks argument was null.

La collection de tasks contenait une tâche null.The tasks collection contained a null task.

Exemples

L’exemple suivant crée un ensemble de tâches qui un test ping sur les URL dans un tableau.The following example creates a set of tasks that ping the URLs in an array. Les tâches sont stockées dans un List<Task> collection qui est passée à la WhenAll(IEnumerable<Task>) (méthode).The tasks are stored in a List<Task> collection that is passed to the WhenAll(IEnumerable<Task>) method. Après l’appel à la Wait méthode garantit que tous les threads sont terminés, l’exemple examine la Task.Status propriété afin de déterminer si toutes les tâches ont généré une erreur.After the call to the Wait method ensures that all threads have completed, the example examines the Task.Status property to determine whether any tasks have faulted.

using System;
using System.Collections.Generic;
using System.Net.NetworkInformation;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      int failed = 0;
      var tasks = new List<Task>();
      String[] urls = { "www.adatum.com", "www.cohovineyard.com",
                        "www.cohowinery.com", "www.northwindtraders.com",
                        "www.contoso.com" };
      
      foreach (var value in urls) {
         var url = value;
         tasks.Add(Task.Run( () => { var png = new Ping();
                                     try {
                                        var reply = png.Send(url);
                                        if (! (reply.Status == IPStatus.Success)) {
                                           Interlocked.Increment(ref failed);
                                           throw new TimeoutException("Unable to reach " + url + ".");
                                        }
                                     }
                                     catch (PingException) {
                                        Interlocked.Increment(ref failed);
                                        throw;
                                     }
                                   }));
      }
      Task t = Task.WhenAll(tasks);
      try {
         t.Wait();
      }
      catch {}   

      if (t.Status == TaskStatus.RanToCompletion)
         Console.WriteLine("All ping attempts succeeded.");
      else if (t.Status == TaskStatus.Faulted)
         Console.WriteLine("{0} ping attempts failed", failed);      
   }
}
// The example displays output like the following:
//       5 ping attempts failed
Imports System.Collections.Generic
Imports System.Net.NetworkInformation
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim failed As Integer = 0
      Dim tasks As New List(Of Task)()
      Dim urls() As String = { "www.adatum.com", "www.cohovineyard.com",
                              "www.cohowinery.com", "www.northwindtraders.com",
                              "www.contoso.com" }
      
      For Each value In urls
         Dim url As String = value
         tasks.Add(Task.Run( Sub()
                                Dim png As New Ping()
                                Try
                                   Dim reply = png.Send(url)
                                   If Not reply.Status = IPStatus.Success Then
                                      Interlocked.Increment(failed)
                                      Throw New TimeoutException("Unable to reach " + url + ".")
                                   End If
                                   Catch e As PingException
                                      Interlocked.Increment(failed)
                                      Throw
                                   End Try
                             End Sub))
      Next
      Dim t As Task = Task.WhenAll(tasks)
      Try
         t.Wait()
      Catch
      End Try   

      If t.Status = TaskStatus.RanToCompletion
         Console.WriteLine("All ping attempts succeeded.")
      ElseIf t.Status = TaskStatus.Faulted
         Console.WriteLine("{0} ping attempts failed", failed)      
      End If
   End Sub
End Module
' The example displays output like the following:
'     5 ping attempts failed

Remarques

Les surcharges de la WhenAll méthode qui retourne un Task objet sont généralement appelées lorsque vous vous intéressez dans l’état d’un ensemble de tâches ou dans les exceptions levées par un ensemble de tâches.The overloads of the WhenAll method that return a Task object are typically called when you are interested in the status of a set of tasks or in the exceptions thrown by a set of tasks.

Notes

L’appel à WhenAll(IEnumerable<Task>) méthode ne bloque pas le thread appelant.The call to WhenAll(IEnumerable<Task>) method does not block the calling thread.

Si une des tâches fournies se termine dans un état d’erreur, la tâche retournée se termine également dans un Faulted état, où ses exceptions contiendra l’agrégation de l’ensemble des exceptions non encapsulées à partir de chacune des tâches fournies.If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.

Si aucune des tâches fournis a généré une erreur, mais au moins un d’eux a été annulé, la tâche retournée se termine dans le Canceled état.If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.

Si aucune des tâches a échoué et aucune des tâches ont été annulées, la tâche qui en résulte se termine dans le RanToCompletion état.If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state.

Si le fourni tableau/énumérable ne contient aucune tâche, la tâche retournée sera immédiatement passer à un RanToCompletion état avant d’être retournée à l’appelant.If the supplied array/enumerable contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller.

WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[])

Crée une tâche qui s’achève quand tous les objets Task d’un tableau sont terminés.Creates a task that will complete when all of the Task objects in an array have completed.

public:
 static System::Threading::Tasks::Task ^ WhenAll(... cli::array <System::Threading::Tasks::Task ^> ^ tasks);
public static System.Threading.Tasks.Task WhenAll (params System.Threading.Tasks.Task[] tasks);
static member WhenAll : System.Threading.Tasks.Task[] -> System.Threading.Tasks.Task
Public Shared Function WhenAll (ParamArray tasks As Task()) As Task

Paramètres

tasks
Task[]

Tâches restantes à exécuter avant la fin.The tasks to wait on for completion.

Retours

Tâche qui représente l'achèvement de toutes les tâches fournies.A task that represents the completion of all of the supplied tasks.

Exceptions

L'argument tasks était null.The tasks argument was null.

Le tableau de tasks contenait une tâche null.The tasks array contained a null task.

Exemples

L’exemple suivant crée un ensemble de tâches qui un test ping sur les URL dans un tableau.The following example creates a set of tasks that ping the URLs in an array. Les tâches sont stockées dans un List<Task> collection qui est convertie en un tableau et transmise à la WhenAll(IEnumerable<Task>) (méthode).The tasks are stored in a List<Task> collection that is converted to an array and passed to the WhenAll(IEnumerable<Task>) method. Après l’appel à la Wait méthode garantit que tous les threads sont terminés, l’exemple examine la Task.Status propriété afin de déterminer si toutes les tâches ont généré une erreur.After the call to the Wait method ensures that all threads have completed, the example examines the Task.Status property to determine whether any tasks have faulted.

using System;
using System.Collections.Generic;
using System.Net.NetworkInformation;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static async Task Main()
   {
      int failed = 0;
      var tasks = new List<Task>();
      String[] urls = { "www.adatum.com", "www.cohovineyard.com",
                        "www.cohowinery.com", "www.northwindtraders.com",
                        "www.contoso.com" };
      
      foreach (var value in urls) {
         var url = value;
         tasks.Add(Task.Run( () => { var png = new Ping();
                                     try {
                                        var reply = png.Send(url);
                                        if (! (reply.Status == IPStatus.Success)) {
                                           Interlocked.Increment(ref failed);
                                           throw new TimeoutException("Unable to reach " + url + ".");
                                        }
                                     }
                                     catch (PingException) {
                                        Interlocked.Increment(ref failed);
                                        throw;
                                     }
                                   }));
      }
      Task t = Task.WhenAll(tasks.ToArray());
      try {
         await t;
      }
      catch {}   

      if (t.Status == TaskStatus.RanToCompletion)
         Console.WriteLine("All ping attempts succeeded.");
      else if (t.Status == TaskStatus.Faulted)
         Console.WriteLine("{0} ping attempts failed", failed);      
   }
}
// The example displays output like the following:
//       5 ping attempts failed
Imports System.Collections.Generic
Imports System.Net.NetworkInformation
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim failed As Integer = 0
      Dim tasks As New List(Of Task)()
      Dim urls() As String = { "www.adatum.com", "www.cohovineyard.com",
                              "www.cohowinery.com", "www.northwindtraders.com",
                              "www.contoso.com" }
      
      For Each value In urls
         Dim url As String = value
         tasks.Add(Task.Run( Sub()
                                Dim png As New Ping()
                                Try
                                   Dim reply = png.Send(url)
                                   If Not reply.Status = IPStatus.Success Then
                                      Interlocked.Increment(failed)
                                      Throw New TimeoutException("Unable to reach " + url + ".")
                                   End If
                                   Catch e As PingException
                                      Interlocked.Increment(failed)
                                      Throw
                                   End Try
                             End Sub))
      Next
      Dim t As Task = Task.WhenAll(tasks.ToArray())
      Try
         t.Wait()
      Catch
      End Try   

      If t.Status = TaskStatus.RanToCompletion
         Console.WriteLine("All ping attempts succeeded.")
      ElseIf t.Status = TaskStatus.Faulted
         Console.WriteLine("{0} ping attempts failed", failed)      
      End If
   End Sub
End Module
' The example displays output like the following:
'     5 ping attempts failed

Remarques

Les surcharges de la WhenAll méthode qui retourne un Task objet sont généralement appelées lorsque vous vous intéressez dans l’état d’un ensemble de tâches ou dans les exceptions levées par un ensemble de tâches.The overloads of the WhenAll method that return a Task object are typically called when you are interested in the status of a set of tasks or in the exceptions thrown by a set of tasks.

Notes

L’appel à WhenAll(Task[]) méthode ne bloque pas le thread appelant.The call to WhenAll(Task[]) method does not block the calling thread.

Si une des tâches fournies se termine dans un état d’erreur, la tâche retournée se termine également dans un Faulted état, où ses exceptions contiendra l’agrégation de l’ensemble des exceptions non encapsulées à partir de chacune des tâches fournies.If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.

Si aucune des tâches fournis a généré une erreur, mais au moins un d’eux a été annulé, la tâche retournée se termine dans le Canceled état.If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.

Si aucune des tâches a échoué et aucune des tâches ont été annulées, la tâche qui en résulte se termine dans le RanToCompletion état.If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state.

Si le fourni tableau/énumérable ne contient aucune tâche, la tâche retournée sera immédiatement passer à un RanToCompletion état avant d’être retournée à l’appelant.If the supplied array/enumerable contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller.

WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>) WhenAll<TResult>(IEnumerable<Task<TResult>>)

Crée une tâche qui s’achève quand tous les objets Task<TResult> d’une collection énumérable sont terminés.Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

public:
generic <typename TResult>
 static System::Threading::Tasks::Task<cli::array <TResult> ^> ^ WhenAll(System::Collections::Generic::IEnumerable<System::Threading::Tasks::Task<TResult> ^> ^ tasks);
public static System.Threading.Tasks.Task<TResult[]> WhenAll<TResult> (System.Collections.Generic.IEnumerable<System.Threading.Tasks.Task<TResult>> tasks);
static member WhenAll : seq<System.Threading.Tasks.Task<'Result>> -> System.Threading.Tasks.Task<'Result[]>
Public Shared Function WhenAll(Of TResult) (tasks As IEnumerable(Of Task(Of TResult))) As Task(Of TResult())

Paramètres de type

TResult

Type de la tâche terminée.The type of the completed task.

Paramètres

tasks
IEnumerable<Task<TResult>>

Tâches restantes à exécuter avant la fin.The tasks to wait on for completion.

Retours

Task<TResult[]>

Tâche qui représente l'achèvement de toutes les tâches fournies.A task that represents the completion of all of the supplied tasks.

Exceptions

L'argument tasks était null.The tasks argument was null.

La collection de tasks contenait une tâche null.The tasks collection contained a null task.

Exemples

L’exemple suivant crée dix tâches, chacun d’eux instancie un générateur de nombres aléatoires qui crée les 1 000 nombres aléatoires compris entre 1 et 1 000 et calcule leur moyenne.The following example creates ten tasks, each of which instantiates a random number generator that creates 1,000 random numbers between 1 and 1,000 and computes their mean. Le Delay(Int32) méthode est utilisée pour retarder l’instanciation de générateurs de nombres aléatoires afin qu’ils ne sont pas créés avec les mêmes valeurs initiales.The Delay(Int32) method is used to delay instantiation of the random number generators so that they are not created with identical seed values. L’appel à la WhenAll méthode renvoie alors un Int64 tableau qui contient la moyenne calculée par chaque tâche.The call to the WhenAll method then returns an Int64 array that contains the mean computed by each task. Ceux-ci sont ensuite utilisés pour calculer la moyenne globale.These are then used to calculate the overall mean.

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var tasks = new List<Task<long>>();
      for (int ctr = 1; ctr <= 10; ctr++) {
         int delayInterval = 18 * ctr;
         tasks.Add(Task.Run(async () => { long total = 0;
                                          await Task.Delay(delayInterval);
                                          var rnd = new Random();
                                          // Generate 1,000 random numbers.
                                          for (int n = 1; n <= 1000; n++)
                                             total += rnd.Next(0, 1000);
                                          return total; } ));
      }
      var continuation = Task.WhenAll(tasks);
      try {
         continuation.Wait();
      }
      catch (AggregateException)
      { }
   
      if (continuation.Status == TaskStatus.RanToCompletion) {
         long grandTotal = 0;
         foreach (var result in continuation.Result) {
            grandTotal += result;
            Console.WriteLine("Mean: {0:N2}, n = 1,000", result/1000.0);
         }
   
         Console.WriteLine("\nMean of Means: {0:N2}, n = 10,000",
                           grandTotal/10000);
      }
      // Display information on faulted tasks.
      else {
         foreach (var t in tasks) {
            Console.WriteLine("Task {0}: {1}", t.Id, t.Status);
         }
      }
   }
}
// The example displays output like the following:
//       Mean: 506.34, n = 1,000
//       Mean: 504.69, n = 1,000
//       Mean: 489.32, n = 1,000
//       Mean: 505.96, n = 1,000
//       Mean: 515.31, n = 1,000
//       Mean: 499.94, n = 1,000
//       Mean: 496.92, n = 1,000
//       Mean: 508.58, n = 1,000
//       Mean: 494.88, n = 1,000
//       Mean: 493.53, n = 1,000
//
//       Mean of Means: 501.55, n = 10,000
Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks As New List(Of Task(Of Long))()
      For ctr As Integer = 1 To 10
         Dim delayInterval As Integer = 18 * ctr
         tasks.Add(Task.Run(Async Function()
                               Dim total As Long = 0
                               Await Task.Delay(delayInterval)
                               Dim rnd As New Random()
                               ' Generate 1,000 random numbers.
                               For n As Integer = 1 To 1000
                                  total += rnd.Next(0, 1000)
                               Next
                               Return total
                            End Function))
      Next
      Dim continuation = Task.WhenAll(tasks)
      Try
         continuation.Wait()
      Catch ae As AggregateException
      End Try
      
      If continuation.Status = TaskStatus.RanToCompletion Then
         Dim grandTotal As Long = 0
         For Each result in continuation.Result
            grandTotal += result
            Console.WriteLine("Mean: {0:N2}, n = 1,000", result/1000)
         Next
         Console.WriteLine()
         Console.WriteLine("Mean of Means: {0:N2}, n = 10,000",
                           grandTotal/10000)
      ' Display information on faulted tasks.
      Else 
         For Each t In tasks
            Console.WriteLine("Task {0}: {1}", t.Id, t.Status)
         Next
      End If
   End Sub
End Module
' The example displays output like the following:
'       Mean: 506.34, n = 1,000
'       Mean: 504.69, n = 1,000
'       Mean: 489.32, n = 1,000
'       Mean: 505.96, n = 1,000
'       Mean: 515.31, n = 1,000
'       Mean: 499.94, n = 1,000
'       Mean: 496.92, n = 1,000
'       Mean: 508.58, n = 1,000
'       Mean: 494.88, n = 1,000
'       Mean: 493.53, n = 1,000
'
'       Mean of Means: 501.55, n = 10,000

Dans ce cas, les dix tâches individuelles sont stockés dans un List<T> objet.In this case, the ten individual tasks are stored in a List<T> object. List<T> implémente l'interface IEnumerable<T>.List<T> implements the IEnumerable<T> interface.

Remarques

L’appel à WhenAll<TResult>(IEnumerable<Task<TResult>>) méthode ne bloque pas le thread appelant.The call to WhenAll<TResult>(IEnumerable<Task<TResult>>) method does not block the calling thread. Toutefois, un appel à retourné Result propriété ne bloque le thread appelant.However, a call to the returned Result property does block the calling thread.

Si une des tâches fournies se termine dans un état d’erreur, la tâche retournée se termine également dans un Faulted état, où ses exceptions contiendra l’agrégation de l’ensemble des exceptions non encapsulées à partir de chacune des tâches fournies.If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.

Si aucune des tâches fournis a généré une erreur, mais au moins un d’eux a été annulé, la tâche retournée se termine dans le Canceled état.If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.

Si aucune des tâches a échoué et aucune des tâches ont été annulées, la tâche qui en résulte se termine dans le RanToCompletion état.If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state. Le Task<TResult>.Result propriété de la tâche retournée est fixée à un tableau contenant tous les résultats des tâches fournies dans le même ordre, car elles ont été fournies (par exemple, si l’entrée des tâches tableau contenu t1, t2, t3, la tâche de sortie Task<TResult>.Result propriété retournera un TResult[]arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).The Task<TResult>.Result property of the returned task will be set to an array containing all of the results of the supplied tasks in the same order as they were provided (e.g. if the input tasks array contained t1, t2, t3, the output task's Task<TResult>.Result property will return an TResult[] where arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Si le tasks argument ne contient aucune tâche, la tâche retournée passe immédiatement à un RanToCompletion état avant d’être retournée à l’appelant.If the tasks argument contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller. Retourné TResult[] sera un tableau d’éléments de 0.The returned TResult[] will be an array of 0 elements.

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

Crée une tâche qui s’achève quand tous les objets Task<TResult> d’un tableau sont terminés.Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

public:
generic <typename TResult>
 static System::Threading::Tasks::Task<cli::array <TResult> ^> ^ WhenAll(... cli::array <System::Threading::Tasks::Task<TResult> ^> ^ tasks);
public static System.Threading.Tasks.Task<TResult[]> WhenAll<TResult> (params System.Threading.Tasks.Task<TResult>[] tasks);
static member WhenAll : System.Threading.Tasks.Task<'Result>[] -> System.Threading.Tasks.Task<'Result[]>
Public Shared Function WhenAll(Of TResult) (ParamArray tasks As Task(Of TResult)()) As Task(Of TResult())

Paramètres de type

TResult

Type de la tâche terminée.The type of the completed task.

Paramètres

tasks
Task<TResult>[]

Tâches restantes à exécuter avant la fin.The tasks to wait on for completion.

Retours

Task<TResult[]>

Tâche qui représente l'achèvement de toutes les tâches fournies.A task that represents the completion of all of the supplied tasks.

Exceptions

L'argument tasks était null.The tasks argument was null.

Le tableau de tasks contenait une tâche null.The tasks array contained a null task.

Exemples

L’exemple suivant crée dix tâches, chacun d’eux instancie un générateur de nombres aléatoires qui crée les 1 000 nombres aléatoires compris entre 1 et 1 000 et calcule leur moyenne.The following example creates ten tasks, each of which instantiates a random number generator that creates 1,000 random numbers between 1 and 1,000 and computes their mean. Dans ce cas, les dix tâches individuelles sont stockés dans un Task<Int64> tableau.In this case, the ten individual tasks are stored in a Task<Int64> array. Le Delay(Int32) méthode est utilisée pour retarder l’instanciation de générateurs de nombres aléatoires afin qu’ils ne sont pas créés avec les mêmes valeurs initiales.The Delay(Int32) method is used to delay instantiation of the random number generators so that they are not created with identical seed values. L’appel à la WhenAll méthode renvoie alors un Int64 tableau qui contient la moyenne calculée par chaque tâche.The call to the WhenAll method then returns an Int64 array that contains the mean computed by each task. Ceux-ci sont ensuite utilisés pour calculer la moyenne globale.These are then used to calculate the overall mean.

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var tasks = new Task<long>[10];
      for (int ctr = 1; ctr <= 10; ctr++) {
         int delayInterval = 18 * ctr;
         tasks[ctr - 1] = Task.Run(async () => { long total = 0;
                                                 await Task.Delay(delayInterval);
                                                 var rnd = new Random();
                                                 // Generate 1,000 random numbers.
                                                 for (int n = 1; n <= 1000; n++)
                                                    total += rnd.Next(0, 1000);

                                                 return total; } );
      }
      var continuation = Task.WhenAll(tasks);
      try {
         continuation.Wait();
      }
      catch (AggregateException)
      {}
   
      if (continuation.Status == TaskStatus.RanToCompletion) {
         long grandTotal = 0;
         foreach (var result in continuation.Result) {
            grandTotal += result;
            Console.WriteLine("Mean: {0:N2}, n = 1,000", result/1000.0);
         }
   
         Console.WriteLine("\nMean of Means: {0:N2}, n = 10,000",
                           grandTotal/10000);
      }
      // Display information on faulted tasks.
      else { 
         foreach (var t in tasks)
            Console.WriteLine("Task {0}: {1}", t.Id, t.Status);
      }
   
   }
}
// The example displays output like the following:
//       Mean: 506.38, n = 1,000
//       Mean: 501.01, n = 1,000
//       Mean: 505.36, n = 1,000
//       Mean: 492.00, n = 1,000
//       Mean: 508.36, n = 1,000
//       Mean: 503.99, n = 1,000
//       Mean: 504.95, n = 1,000
//       Mean: 508.58, n = 1,000
//       Mean: 490.23, n = 1,000
//       Mean: 501.59, n = 1,000
//
//       Mean of Means: 502.00, n = 10,000
Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks(9) As Task(Of Long)
      For ctr As Integer = 1 To 10
         Dim delayInterval As Integer = 18 * ctr
         tasks(ctr - 1) =Task.Run(Async Function()
                                     Dim total As Long = 0
                                     Await Task.Delay(delayInterval)
                                     Dim rnd As New Random()
                                     ' Generate 1,000 random numbers.
                                     For n As Integer = 1 To 1000
                                        total += rnd.Next(0, 1000)
                                     Next
                                     Return total
                                  End Function)
      Next
      Dim continuation = Task.WhenAll(tasks)
      Try
         continuation.Wait()
      Catch ae As AggregateException
      End Try
         
      If continuation.Status = TaskStatus.RanToCompletion Then
         Dim grandTotal As Long = 0
         For Each result in continuation.Result
            grandTotal += result
            Console.WriteLine("Mean: {0:N2}, n = 1,000", result/1000)
         Next
         Console.WriteLine()
         Console.WriteLine("Mean of Means: {0:N2}, n = 10,000",
                           grandTotal/10000)
      ' Display information on faulted tasks.
      Else 
         For Each t In tasks
            Console.WriteLine("Task {0}: {1}", t.Id, t.Status)
         Next
      End If
   End Sub
End Module
' The example displays output like the following:
'       Mean: 506.38, n = 1,000
'       Mean: 501.01, n = 1,000
'       Mean: 505.36, n = 1,000
'       Mean: 492.00, n = 1,000
'       Mean: 508.36, n = 1,000
'       Mean: 503.99, n = 1,000
'       Mean: 504.95, n = 1,000
'       Mean: 508.58, n = 1,000
'       Mean: 490.23, n = 1,000
'       Mean: 501.59, n = 1,000
'
'       Mean of Means: 502.00, n = 10,000

Remarques

L’appel à WhenAll<TResult>(Task<TResult>[]) méthode ne bloque pas le thread appelant.The call to WhenAll<TResult>(Task<TResult>[]) method does not block the calling thread. Toutefois, un appel à retourné Result propriété ne bloque le thread appelant.However, a call to the returned Result property does block the calling thread.

Si une des tâches fournies se termine dans un état d’erreur, la tâche retournée se termine également dans un Faulted état, où ses exceptions contiendra l’agrégation de l’ensemble des exceptions non encapsulées à partir de chacune des tâches fournies.If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.

Si aucune des tâches fournis a généré une erreur, mais au moins un d’eux a été annulé, la tâche retournée se termine dans le Canceled état.If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.

Si aucune des tâches a échoué et aucune des tâches ont été annulées, la tâche qui en résulte se termine dans le RanToCompletion état.If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state. Le Result de la tâche retournée est défini sur un tableau contenant tous les résultats des tâches fournies dans le même ordre, car elles ont été fournies (par exemple, si l’entrée des tâches tableau contenu t1, t2, t3, la tâche de sortie Result retournera un TResult[]arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).The Result of the returned task will be set to an array containing all of the results of the supplied tasks in the same order as they were provided (e.g. if the input tasks array contained t1, t2, t3, the output task's Result will return an TResult[] where arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Si le fourni tableau/énumérable ne contient aucune tâche, la tâche retournée sera immédiatement passer à un RanToCompletion état avant d’être retournée à l’appelant.If the supplied array/enumerable contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller. Retourné TResult[] sera un tableau d’éléments de 0.The returned TResult[] will be an array of 0 elements.

S’applique à