Compartir por

Task.WhenAll Método

Definición

Espacio de nombres:
System.Threading.Tasks
Ensamblados:
mscorlib.dll, System.Threading.Tasks.dll
Ensamblados:
netstandard.dll, System.Runtime.dll
Ensamblado:
System.Threading.Tasks.dll
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Crea una tarea que se completará cuando se hayan completado todas las tareas proporcionadas.

Sobrecargas

Nombre Description
WhenAll(IEnumerable<Task>)

Crea una tarea que se completará cuando se hayan completado todos los Task objetos de una colección enumerable.
WhenAll(ReadOnlySpan<Task>)

Crea una tarea que se completará cuando se hayan completado todas las tareas proporcionadas.
WhenAll(Task[])

Crea una tarea que se completará cuando se hayan completado todos los Task objetos de una matriz.
WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)

Crea una tarea que se completará cuando se hayan completado todas las tareas proporcionadas.
WhenAll<TResult>(IEnumerable<Task<TResult>>)

Crea una tarea que se completará cuando se hayan completado todos los Task<TResult> objetos de una colección enumerable.
WhenAll<TResult>(Task<TResult>[])

Crea una tarea que se completará cuando se hayan completado todos los Task<TResult> objetos de una matriz.

WhenAll(IEnumerable<Task>)

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

Crea una tarea que se completará cuando se hayan completado todos los Task objetos de una colección enumerable.

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

Parámetros

tasks
IEnumerable<Task>

Las tareas que se van a esperar para completarse.

Devoluciones

Task

Tarea que representa la finalización de todas las tareas proporcionadas.

Excepciones

ArgumentNullException

El tasks argumento era null.

ArgumentException

La tasks colección contenía una null tarea.

Ejemplos

En el ejemplo siguiente se crea un conjunto de tareas que hacen ping a las direcciones URL de una matriz. Las tareas se almacenan en una List<Task> colección que se pasa al WhenAll(IEnumerable<Task>) método . Una vez que la llamada al Wait método garantiza que se hayan completado todos los subprocesos, en el ejemplo se examina la Task.Status propiedad para determinar si alguna tarea ha fallado.

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

Comentarios

Las sobrecargas del WhenAll método que devuelven un Task objeto suelen llamarse cuando está interesado en el estado de un conjunto de tareas o en las excepciones producidas por un conjunto de tareas.

Nota

La llamada al WhenAll(IEnumerable<Task>) método no bloquea el subproceso que realiza la llamada.

Si alguna de las tareas proporcionadas se completa en un estado defectuoso, la tarea devuelta también se completará en un Faulted estado, donde sus excepciones contendrán la agregación del conjunto de excepciones desajustadas de cada una de las tareas proporcionadas.

Si no se ha producido ningún error en las tareas proporcionadas, pero al menos se canceló una de ellas, la tarea devuelta finalizará en el Canceled estado .

Si no se ha producido ningún error en ninguna de las tareas y ninguna de las tareas se canceló, la tarea resultante finalizará en el RanToCompletion estado.

Si la matriz o enumerable proporcionada no contiene ninguna tarea, la tarea devuelta pasará inmediatamente a un RanToCompletion estado antes de que se devuelva al autor de la llamada.

Se aplica a

WhenAll(ReadOnlySpan<Task>)

Source:
Task.cs
Source:
Task.cs

Crea una tarea que se completará cuando se hayan completado todas las tareas proporcionadas.

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

Parámetros

tasks
ReadOnlySpan<Task>

Las tareas que se van a esperar para completarse.

Devoluciones

Task

Tarea que representa la finalización de todas las tareas proporcionadas.

Excepciones

ArgumentException

La tasks matriz contiene una null tarea.

Comentarios

Si alguna de las tareas proporcionadas se completa en un estado defectuoso, la tarea devuelta también se completará en un estado Defectuoso, donde sus excepciones contendrán la agregación del conjunto de excepciones desencapsuladas de cada una de las tareas proporcionadas.

Si no se ha producido ningún error en las tareas proporcionadas, pero al menos se canceló una de ellas, la tarea devuelta finalizará en estado Cancelado.

Si no se ha producido ningún error en las tareas y ninguna de las tareas se canceló, la tarea resultante finalizará en el estado RanToCompletion.

Si el intervalo proporcionado no contiene ninguna tarea, la tarea devuelta pasará inmediatamente a un estado RanToCompletion antes de que se devuelva al autor de la llamada.

Se aplica a

WhenAll(Task[])

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

Crea una tarea que se completará cuando se hayan completado todos los Task objetos de una matriz.

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

Parámetros

tasks
Task[]

Las tareas que se van a esperar para completarse.

Devoluciones

Task

Tarea que representa la finalización de todas las tareas proporcionadas.

Excepciones

ArgumentNullException

El tasks argumento era null.

ArgumentException

La tasks matriz contenía una null tarea.

Ejemplos

En el ejemplo siguiente se crea un conjunto de tareas que hacen ping a las direcciones URL de una matriz. Las tareas se almacenan en una List<Task> colección que se convierte en una matriz y se pasan al WhenAll(IEnumerable<Task>) método . Una vez que la llamada al Wait método garantiza que se hayan completado todos los subprocesos, en el ejemplo se examina la Task.Status propiedad para determinar si alguna tarea ha fallado.

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

Comentarios

Las sobrecargas del WhenAll método que devuelven un Task objeto suelen llamarse cuando está interesado en el estado de un conjunto de tareas o en las excepciones producidas por un conjunto de tareas.

Nota

La llamada al WhenAll(Task[]) método no bloquea el subproceso que realiza la llamada.

Si alguna de las tareas proporcionadas se completa en un estado defectuoso, la tarea devuelta también se completará en un Faulted estado, donde sus excepciones contendrán la agregación del conjunto de excepciones desajustadas de cada una de las tareas proporcionadas.

Si no se ha producido ningún error en las tareas proporcionadas, pero al menos se canceló una de ellas, la tarea devuelta finalizará en el Canceled estado .

Si no se ha producido ningún error en ninguna de las tareas y ninguna de las tareas se canceló, la tarea resultante finalizará en el RanToCompletion estado.

Si la matriz o enumerable proporcionada no contiene ninguna tarea, la tarea devuelta pasará inmediatamente a un RanToCompletion estado antes de que se devuelva al autor de la llamada.

Se aplica a

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

Source:
Task.cs
Source:
Task.cs

Crea una tarea que se completará cuando se hayan completado todas las tareas proporcionadas.

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

Parámetros de tipo

TResult

Tipo del resultado devuelto por las tareas.

Parámetros

tasks
ReadOnlySpan<Task<TResult>>

Las tareas que se van a esperar para completarse.

Devoluciones

Task<TResult[]>

Tarea que representa la finalización de todas las tareas proporcionadas.

Excepciones

ArgumentException

La tasks matriz contiene una null tarea.

Comentarios

Si alguna de las tareas proporcionadas se completa en un estado defectuoso, la tarea devuelta también se completará en un estado Defectuoso, donde sus excepciones contendrán la agregación del conjunto de excepciones desencapsuladas de cada una de las tareas proporcionadas.

Si no se ha producido ningún error en las tareas proporcionadas, pero al menos se canceló una de ellas, la tarea devuelta finalizará en estado Cancelado.

Si no se ha producido ningún error en las tareas y ninguna de las tareas se canceló, la tarea resultante finalizará en el estado RanToCompletion. El resultado de la tarea devuelta se establecerá en una matriz que contenga todos los resultados de las tareas proporcionadas en el mismo orden que se proporcionaron (por ejemplo, si la matriz de tareas de entrada contenía t1, t2, t3, el resultado de la tarea de salida devolverá un TResult[] donde arr[0] == t1. Result, arr[1] == t2. Result, and arr[2] == t3. Resultado).

Si la matriz o enumerable proporcionada no contiene ninguna tarea, la tarea devuelta pasará inmediatamente a un estado RanToCompletion antes de que se devuelva al autor de la llamada. El TResult[] devuelto será una matriz de 0 elementos.

Se aplica a

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

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

Crea una tarea que se completará cuando se hayan completado todos los Task<TResult> objetos de una colección enumerable.

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

Parámetros de tipo

TResult

Tipo de la tarea completada.

Parámetros

tasks
IEnumerable<Task<TResult>>

Las tareas que se van a esperar para completarse.

Devoluciones

Task<TResult[]>

Tarea que representa la finalización de todas las tareas proporcionadas.

Excepciones

ArgumentNullException

El tasks argumento era null.

ArgumentException

La tasks colección contenía una null tarea.

Ejemplos

En el ejemplo siguiente se crean diez tareas, cada una de las cuales crea una instancia de un generador de números aleatorios que crea 1000 números aleatorios entre 1 y 1000 y calcula su media. El Delay(Int32) método se usa para retrasar la creación de instancias de los generadores de números aleatorios para que no se creen con valores de inicialización idénticos. A continuación, la llamada al WhenAll método devuelve una Int64 matriz que contiene la media calculada por cada tarea. A continuación, se usan para calcular la media global.

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

En este caso, las diez tareas individuales se almacenan en un List<T> objeto . List<T> implementa la IEnumerable<T> interfaz .

Comentarios

La llamada al WhenAll<TResult>(IEnumerable<Task<TResult>>) método no bloquea el subproceso que realiza la llamada. Sin embargo, una llamada a la propiedad devuelta Result bloquea el subproceso que realiza la llamada.

Si alguna de las tareas proporcionadas se completa en un estado defectuoso, la tarea devuelta también se completará en un Faulted estado, donde sus excepciones contendrán la agregación del conjunto de excepciones desajustadas de cada una de las tareas proporcionadas.

Si no se ha producido ningún error en las tareas proporcionadas, pero al menos se canceló una de ellas, la tarea devuelta finalizará en el Canceled estado .

Si no se ha producido ningún error en ninguna de las tareas y ninguna de las tareas se canceló, la tarea resultante finalizará en el RanToCompletion estado. La Task<TResult>.Result propiedad de la tarea devuelta se establecerá en una matriz que contiene todos los resultados de las tareas proporcionadas en el mismo orden que se proporcionaron (por ejemplo, si la matriz de tareas de entrada contenía t1, t2, t3, la propiedad de la tarea de Task<TResult>.Result salida devolverá un TResult[] donde arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Si el tasks argumento no contiene ninguna tarea, la tarea devuelta pasará inmediatamente a un RanToCompletion estado antes de que se devuelva al autor de la llamada. El devuelto TResult[] será una matriz de 0 elementos.

Se aplica a

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

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

Crea una tarea que se completará cuando se hayan completado todos los Task<TResult> objetos de una matriz.

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

Parámetros de tipo

TResult

Tipo de la tarea completada.

Parámetros

tasks
Task<TResult>[]

Las tareas que se van a esperar para completarse.

Devoluciones

Task<TResult[]>

Tarea que representa la finalización de todas las tareas proporcionadas.

Excepciones

ArgumentNullException

El tasks argumento era null.

ArgumentException

La tasks matriz contenía una null tarea.

Ejemplos

En el ejemplo siguiente se crean diez tareas, cada una de las cuales crea una instancia de un generador de números aleatorios que crea 1000 números aleatorios entre 1 y 1000 y calcula su media. En este caso, las diez tareas individuales se almacenan en una Task<Int64> matriz. El Delay(Int32) método se usa para retrasar la creación de instancias de los generadores de números aleatorios para que no se creen con valores de inicialización idénticos. A continuación, la llamada al WhenAll método devuelve una Int64 matriz que contiene la media calculada por cada tarea. A continuación, se usan para calcular la media global.

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

Comentarios

La llamada al WhenAll<TResult>(Task<TResult>[]) método no bloquea el subproceso que realiza la llamada. Sin embargo, una llamada a la propiedad devuelta Result bloquea el subproceso que realiza la llamada.

Si alguna de las tareas proporcionadas se completa en un estado defectuoso, la tarea devuelta también se completará en un Faulted estado, donde sus excepciones contendrán la agregación del conjunto de excepciones desajustadas de cada una de las tareas proporcionadas.

Si no se ha producido ningún error en las tareas proporcionadas, pero al menos se canceló una de ellas, la tarea devuelta finalizará en el Canceled estado .

Si no se ha producido ningún error en ninguna de las tareas y ninguna de las tareas se canceló, la tarea resultante finalizará en el RanToCompletion estado. El Result de la tarea devuelta se establecerá en una matriz que contiene todos los resultados de las tareas proporcionadas en el mismo orden que se proporcionaron (por ejemplo, si la matriz de tareas de entrada contenía t1, t2, t3, la tarea de Result salida devolverá un TResult[] donde arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Si la matriz o enumerable proporcionada no contiene ninguna tarea, la tarea devuelta pasará inmediatamente a un RanToCompletion estado antes de que se devuelva al autor de la llamada. El devuelto TResult[] será una matriz de 0 elementos.

Se aplica a