Task.WhenAll Méthode

  • Référence

Définition

Espace de noms:
System.Threading.Tasks
Assembly:
System.Threading.Tasks.dll
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Crée une tâche qui se termine lorsque toutes les tâches fournies sont terminées.

Surcharges

WhenAll(IEnumerable<Task>)

Crée une tâche qui se termine lorsque tous les objets Task d’une collection énumérable sont terminés.
WhenAll(ReadOnlySpan<Task>)

Crée une tâche qui se termine lorsque toutes les tâches fournies sont terminées.
WhenAll(Task[])

Crée une tâche qui se termine lorsque tous les objets Task d’un tableau sont terminés.
WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)

Crée une tâche qui se termine lorsque toutes les tâches fournies sont terminées.
WhenAll<TResult>(IEnumerable<Task<TResult>>)

Crée une tâche qui se termine lorsque tous les objets Task<TResult> d’une collection énumérable sont terminés.
WhenAll<TResult>(Task<TResult>[])

Crée une tâche qui se termine lorsque tous les objets Task<TResult> d’un tableau sont terminés.

WhenAll(IEnumerable<Task>)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Crée une tâche qui se termine lorsque tous les objets Task d’une collection énumérable sont terminés.

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 à attendre pour l’achèvement.

Retours

Task

Tâche qui représente l’achèvement de toutes les tâches fournies.

Exceptions

ArgumentNullException

L’argument tasks était null.

ArgumentException

La collection tasks contenait une tâche null.

Exemples

L’exemple suivant crée un ensemble de tâches qui effectuent un test ping sur les URL d’un tableau. Les tâches sont stockées dans une collection List<Task> transmise à la méthode WhenAll(IEnumerable<Task>). Une fois l’appel à la méthode Wait s’assurer que tous les threads ont terminé, l’exemple examine la propriété Task.Status pour déterminer si des tâches ont été défectueuses.

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

open System
open System.Net.NetworkInformation
open System.Threading
open System.Threading.Tasks

let mutable failed = 0

let urls =
    [ "www.adatum.com"
      "www.cohovineyard.com"
      "www.cohowinery.com"
      "www.northwindtraders.com"
      "www.contoso.com" ]

let tasks =
    urls
    |> List.map (fun url ->
        Task.Run(fun () ->
            let png = new Ping()

            try
                let reply = png.Send url

                if reply.Status <> IPStatus.Success then
                    Interlocked.Increment &failed |> ignore
                    raise (TimeoutException $"Unable to reach {url}.")
            with :? PingException ->
                Interlocked.Increment &failed |> ignore
                reraise ()))

let t = Task.WhenAll tasks

try
    t.Wait()
with _ ->
    ()

if t.Status = TaskStatus.RanToCompletion then
    printfn "All ping attempts succeeded."
elif t.Status = TaskStatus.Faulted then
    printfn $"{failed} ping attempts 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 méthode WhenAll qui retournent un objet Task sont généralement appelées lorsque vous êtes intéressé par l’état d’un ensemble de tâches ou dans les exceptions levées par un ensemble de tâches.

Note

L’appel à WhenAll(IEnumerable<Task>) méthode ne bloque pas le thread appelant.

Si l’une des tâches fournies se termine dans un état défectueux, la tâche retournée se termine également dans un état Faulted, où ses exceptions contiennent l’agrégation de l’ensemble d’exceptions non extraites de chacune des tâches fournies.

Si aucune des tâches fournies n’a été défectueuse, mais qu’au moins l’une d’entre elles a été annulée, la tâche retournée se termine dans l’état Canceled.

Si aucune des tâches n’a été défectueuse et qu’aucune des tâches n’a été annulée, la tâche résultante se termine à l’état RanToCompletion.

Si le tableau/énumérable fourni ne contient aucune tâche, la tâche retournée passe immédiatement à un état RanToCompletion avant qu’elle ne soit retournée à l’appelant.

S’applique à

WhenAll(ReadOnlySpan<Task>)

Crée une tâche qui se termine lorsque toutes les tâches fournies sont terminées.

public:
 static System::Threading::Tasks::Task ^ WhenAll(ReadOnlySpan<System::Threading::Tasks::Task ^> tasks);
public static System.Threading.Tasks.Task WhenAll (scoped ReadOnlySpan<System.Threading.Tasks.Task> tasks);
static member WhenAll : ReadOnlySpan<System.Threading.Tasks.Task> -> System.Threading.Tasks.Task
Public Shared Function WhenAll (tasks As ReadOnlySpan(Of Task)) As Task

Paramètres

tasks
ReadOnlySpan<Task>

Tâches à attendre pour l’achèvement.

Retours

Task

Tâche qui représente l’achèvement de toutes les tâches fournies.

Exceptions

ArgumentException

Le tableau tasks contient une tâche null.

Remarques

Si l’une des tâches fournies se termine dans un état d’erreur, la tâche retournée se termine également dans un état d’erreur, où ses exceptions contiennent l’agrégation de l’ensemble d’exceptions non extraites de chacune des tâches fournies.

Si aucune des tâches fournies n’a été défectueuse, mais qu’au moins l’une d’entre elles a été annulée, la tâche retournée se termine à l’état Annulé.

Si aucune des tâches n’a été défectueuse et qu’aucune des tâches n’a été annulée, la tâche résultante se termine par l’état RanToCompletion.

Si l’étendue fournie ne contient aucune tâche, la tâche retournée passe immédiatement à un état RanToCompletion avant son retour à l’appelant.

S’applique à

WhenAll(Task[])

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Crée une tâche qui se termine lorsque tous les objets Task d’un tableau sont terminés.

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 à attendre pour l’achèvement.

Retours

Task

Tâche qui représente l’achèvement de toutes les tâches fournies.

Exceptions

ArgumentNullException

L’argument tasks était null.

ArgumentException

Le tableau tasks contenait une tâche de null.

Exemples

L’exemple suivant crée un ensemble de tâches qui effectuent un test ping sur les URL d’un tableau. Les tâches sont stockées dans une collection List<Task> convertie en tableau et transmises à la méthode WhenAll(IEnumerable<Task>). Une fois l’appel à la méthode Wait s’assurer que tous les threads ont terminé, l’exemple examine la propriété Task.Status pour déterminer si des tâches ont été défectueuses.

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

open System
open System.Net.NetworkInformation
open System.Threading
open System.Threading.Tasks

let mutable failed = 0

let urls =
    [| "www.adatum.com"
       "www.cohovineyard.com"
       "www.cohowinery.com"
       "www.northwindtraders.com"
       "www.contoso.com" |]

let tasks =
    urls
    |> Array.map (fun url ->
        Task.Run(fun () ->
            let png = new Ping()

            try
                let reply = png.Send url

                if reply.Status <> IPStatus.Success then
                    Interlocked.Increment &failed |> ignore
                    raise (TimeoutException $"Unable to reach {url}.")
            with :? PingException ->
                Interlocked.Increment &failed |> ignore
                reraise ()))

let main =
    task {
        let t = Task.WhenAll tasks

        try
            do! t
        with _ ->
            ()

        if t.Status = TaskStatus.RanToCompletion then
            printfn "All ping attempts succeeded."
        elif t.Status = TaskStatus.Faulted then
            printfn $"{failed} ping attempts failed"
    }

main.Wait()
// 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 méthode WhenAll qui retournent un objet Task sont généralement appelées lorsque vous êtes intéressé par l’état d’un ensemble de tâches ou dans les exceptions levées par un ensemble de tâches.

Note

L’appel à WhenAll(Task[]) méthode ne bloque pas le thread appelant.

Si l’une des tâches fournies se termine dans un état défectueux, la tâche retournée se termine également dans un état Faulted, où ses exceptions contiennent l’agrégation de l’ensemble d’exceptions non extraites de chacune des tâches fournies.

Si aucune des tâches fournies n’a été défectueuse, mais qu’au moins l’une d’entre elles a été annulée, la tâche retournée se termine dans l’état Canceled.

Si aucune des tâches n’a été défectueuse et qu’aucune des tâches n’a été annulée, la tâche résultante se termine à l’état RanToCompletion.

Si le tableau/énumérable fourni ne contient aucune tâche, la tâche retournée passe immédiatement à un état RanToCompletion avant qu’elle ne soit retournée à l’appelant.

S’applique à

WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)

Crée une tâche qui se termine lorsque toutes les tâches fournies sont terminées.

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

Paramètres de type

TResult

Paramètres

tasks
ReadOnlySpan<Task<TResult>>

Tâches à attendre pour l’achèvement.

Retours

Task<TResult[]>

Tâche qui représente l’achèvement de toutes les tâches fournies.

Exceptions

ArgumentException

Le tableau tasks contient une tâche null.

Remarques

Si l’une des tâches fournies se termine dans un état d’erreur, la tâche retournée se termine également dans un état d’erreur, où ses exceptions contiennent l’agrégation de l’ensemble d’exceptions non extraites de chacune des tâches fournies.

Si aucune des tâches fournies n’a été défectueuse, mais qu’au moins l’une d’entre elles a été annulée, la tâche retournée se termine à l’état Annulé.

Si aucune des tâches n’a été défectueuse et qu’aucune des tâches n’a été annulée, la tâche résultante se termine par l’état RanToCompletion. Le résultat 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 qu’ils ont été fournis (par exemple, si le tableau des tâches d’entrée contenait t1, t2, t3, le résultat de la tâche de sortie retourne un TResult[] où arr[0] == t1. Résultat, arr[1] == t2. Résultat et arr[2] == t3. Résultat).

Si le tableau/énumérable fourni ne contient aucune tâche, la tâche retournée passe immédiatement à un état RanToCompletion avant son retour à l’appelant. Le TResult[] retourné est un tableau de 0 éléments.

S’applique à

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

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Crée une tâche qui se termine lorsque tous les objets Task<TResult> d’une collection énumérable sont terminés.

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.

Paramètres

tasks
IEnumerable<Task<TResult>>

Tâches à attendre pour l’achèvement.

Retours

Task<TResult[]>

Tâche qui représente l’achèvement de toutes les tâches fournies.

Exceptions

ArgumentNullException

L’argument tasks était null.

ArgumentException

La collection tasks contenait une tâche null.

Exemples

L’exemple suivant crée dix tâches, chacune instancie un générateur de nombres aléatoires qui crée 1 000 nombres aléatoires compris entre 1 et 1 000 et calcule leur moyenne. La méthode Delay(Int32) est utilisée pour retarder l’instanciation des générateurs de nombres aléatoires afin qu’elles ne soient pas créées avec des valeurs initiales identiques. L’appel à la méthode WhenAll retourne ensuite un tableau Int64 qui contient la moyenne calculée par chaque tâche. Ils sont ensuite utilisés pour calculer la moyenne globale.

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

open System
open System.Threading.Tasks

let tasks =
    [| for i = 1 to 10 do
           let delayInterval = 18 * i

           task {
               let mutable total = 0L
               do! Task.Delay delayInterval
               let rnd = Random()

               for _ = 1 to 1000 do
                   total <- total + (rnd.Next(0, 1000) |> int64)

               return total
           } |]

let continuation = Task.WhenAll tasks

try
    continuation.Wait()

with :? AggregateException ->
    ()

if continuation.Status = TaskStatus.RanToCompletion then
    for result in continuation.Result do
        printfn $"Mean: {float result / 1000.:N2}, n = 1,000"

    let grandTotal = continuation.Result |> Array.sum

    printfn $"\nMean of Means: {float grandTotal / 10000.:N2}, n = 10,000"

// Display information on faulted tasks.
else
    for t in tasks do
        printfn $"Task {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ées dans un objet List<T>. List<T> implémente l’interface IEnumerable<T>.

Remarques

L’appel à WhenAll<TResult>(IEnumerable<Task<TResult>>) méthode ne bloque pas le thread appelant. Toutefois, un appel à la propriété Result retournée bloque le thread appelant.

Si l’une des tâches fournies se termine dans un état défectueux, la tâche retournée se termine également dans un état Faulted, où ses exceptions contiennent l’agrégation de l’ensemble d’exceptions non extraites de chacune des tâches fournies.

Si aucune des tâches fournies n’a été défectueuse, mais qu’au moins l’une d’entre elles a été annulée, la tâche retournée se termine dans l’état Canceled.

Si aucune des tâches n’a été défectueuse et qu’aucune des tâches n’a été annulée, la tâche résultante se termine à l’état RanToCompletion. La propriété Task<TResult>.Result de la tâche retournée est définie sur un tableau contenant tous les résultats des tâches fournies dans le même ordre qu’elles ont été fournies (par exemple, si le tableau des tâches d’entrée contenait t1, t2, t3, la propriété Task<TResult>.Result de la tâche de sortie retourne une TResult[] où arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Si l’argument tasks ne contient aucune tâche, la tâche retournée passe immédiatement à un état de RanToCompletion avant qu’elle ne soit retournée à l’appelant. La TResult[] retournée est un tableau de 0 éléments.

S’applique à

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

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Crée une tâche qui se termine lorsque tous les objets Task<TResult> d’un tableau sont terminés.

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.

Paramètres

tasks
Task<TResult>[]

Tâches à attendre pour l’achèvement.

Retours

Task<TResult[]>

Tâche qui représente l’achèvement de toutes les tâches fournies.

Exceptions

ArgumentNullException

L’argument tasks était null.

ArgumentException

Le tableau tasks contenait une tâche de null.

Exemples

L’exemple suivant crée dix tâches, chacune instancie un générateur de nombres aléatoires qui crée 1 000 nombres aléatoires compris entre 1 et 1 000 et calcule leur moyenne. Dans ce cas, les dix tâches individuelles sont stockées dans un tableau Task<Int64>. La méthode Delay(Int32) est utilisée pour retarder l’instanciation des générateurs de nombres aléatoires afin qu’elles ne soient pas créées avec des valeurs initiales identiques. L’appel à la méthode WhenAll retourne ensuite un tableau Int64 qui contient la moyenne calculée par chaque tâche. Ils sont ensuite utilisés pour calculer la moyenne globale.

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

open System
open System.Threading.Tasks

let tasks =
    [| for i = 1 to 10 do
           let delayInterval = 18 * i

           task {
               let mutable total = 0L
               do! Task.Delay delayInterval
               let rnd = Random()

               for _ = 1 to 1000 do
                   total <- total + (rnd.Next(0, 1000) |> int64)

               return total
           } |]

let continuation = Task.WhenAll tasks

try
    continuation.Wait()

with :? AggregateException ->
    ()

if continuation.Status = TaskStatus.RanToCompletion then
    for result in continuation.Result do
        printfn $"Mean: {float result / 1000.:N2}, n = 1,000"

    let grandTotal = Array.sum continuation.Result

    printfn $"\nMean of Means: {float grandTotal / 10000.:N2}, n = 10,000"

// Display information on faulted tasks.
else
    for t in tasks do
        printfn $"Task {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. Toutefois, un appel à la propriété Result retournée bloque le thread appelant.

Si l’une des tâches fournies se termine dans un état défectueux, la tâche retournée se termine également dans un état Faulted, où ses exceptions contiennent l’agrégation de l’ensemble d’exceptions non extraites de chacune des tâches fournies.

Si aucune des tâches fournies n’a été défectueuse, mais qu’au moins l’une d’entre elles a été annulée, la tâche retournée se termine dans l’état Canceled.

Si aucune des tâches n’a été défectueuse et qu’aucune des tâches n’a été annulée, la tâche résultante se termine à l’état RanToCompletion. La Result de la tâche retournée est définie sur un tableau contenant tous les résultats des tâches fournies dans le même ordre qu’ils ont été fournis (par exemple, si le tableau des tâches d’entrée contenait t1, t2, t3, la Result tâche de sortie retourne une TResult[] où arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Si le tableau/énumérable fourni ne contient aucune tâche, la tâche retournée passe immédiatement à un état RanToCompletion avant qu’elle ne soit retournée à l’appelant. La TResult[] retournée est un tableau de 0 éléments.

S’applique à