Task.WhenAll Método

  • Referência

Definição

Namespace:
System.Threading.Tasks
Assembly:
System.Threading.Tasks.dll
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Cria uma tarefa que será concluída quando todas as tarefas fornecidas forem concluídas.

Sobrecargas

WhenAll(IEnumerable<Task>)

Cria uma tarefa que será concluída quando todos os objetos Task em uma coleção enumerável forem concluídos.
WhenAll(ReadOnlySpan<Task>)

Cria uma tarefa que será concluída quando todas as tarefas fornecidas forem concluídas.
WhenAll(Task[])

Cria uma tarefa que será concluída quando todos os objetos Task em uma matriz forem concluídos.
WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)

Cria uma tarefa que será concluída quando todas as tarefas fornecidas forem concluídas.
WhenAll<TResult>(IEnumerable<Task<TResult>>)

Cria uma tarefa que será concluída quando todos os objetos Task<TResult> em uma coleção enumerável forem concluídos.
WhenAll<TResult>(Task<TResult>[])

Cria uma tarefa que será concluída quando todos os objetos Task<TResult> em uma matriz forem concluídos.

WhenAll(IEnumerable<Task>)

Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs

Cria uma tarefa que será concluída quando todos os objetos Task em uma coleção enumerável forem concluídos.

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>

As tarefas a serem aguardadas para conclusão.

Retornos

Task

Uma tarefa que representa a conclusão de todas as tarefas fornecidas.

Exceções

ArgumentNullException

O argumento tasks foi null.

ArgumentException

A coleção tasks continha uma tarefa null.

Exemplos

O exemplo a seguir cria um conjunto de tarefas que pingam as URLs em uma matriz. As tarefas são armazenadas em uma coleção de List<Task> que é passada para o método WhenAll(IEnumerable<Task>). Após a chamada para o método Wait garante que todos os threads tenham sido concluídos, o exemplo examinará a propriedade Task.Status para determinar se alguma tarefa falhou.

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

Comentários

As sobrecargas do método WhenAll que retornam um objeto Task normalmente são chamadas quando você está interessado no status de um conjunto de tarefas ou nas exceções geradas por um conjunto de tarefas.

Nota

A chamada para WhenAll(IEnumerable<Task>) método não bloqueia o thread de chamada.

Se qualquer uma das tarefas fornecidas for concluída em um estado com falha, a tarefa retornada também será concluída em um estado Faulted, em que suas exceções conterão a agregação do conjunto de exceções desembrulhadas de cada uma das tarefas fornecidas.

Se nenhuma das tarefas fornecidas falhar, mas pelo menos uma delas tiver sido cancelada, a tarefa retornada terminará no estado Canceled.

Se nenhuma das tarefas tiver falha e nenhuma das tarefas tiver sido cancelada, a tarefa resultante terminará no estado RanToCompletion.

Se a matriz/enumerável fornecida não contiver tarefas, a tarefa retornada fará a transição imediata para um estado RanToCompletion antes de ser retornada ao chamador.

Aplica-se a

WhenAll(ReadOnlySpan<Task>)

Cria uma tarefa que será concluída quando todas as tarefas fornecidas forem concluídas.

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>

As tarefas a serem aguardadas para conclusão.

Retornos

Task

Uma tarefa que representa a conclusão de todas as tarefas fornecidas.

Exceções

ArgumentException

A matriz tasks contém uma tarefa null.

Comentários

Se qualquer uma das tarefas fornecidas for concluída em um estado com falha, a tarefa retornada também será concluída em um estado com falha, em que suas exceções conterão a agregação do conjunto de exceções desembrulhadas de cada uma das tarefas fornecidas.

Se nenhuma das tarefas fornecidas falhar, mas pelo menos uma delas tiver sido cancelada, a tarefa retornada terminará no estado Cancelado.

Se nenhuma das tarefas tiver falha e nenhuma das tarefas tiver sido cancelada, a tarefa resultante terminará no estado RanToCompletion.

Se o intervalo fornecido não contiver tarefas, a tarefa retornada fará a transição imediata para um estado RanToCompletion antes de ser retornada para o chamador.

Aplica-se a

WhenAll(Task[])

Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs

Cria uma tarefa que será concluída quando todos os objetos Task em uma matriz forem concluídos.

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

As tarefas a serem aguardadas para conclusão.

Retornos

Task

Uma tarefa que representa a conclusão de todas as tarefas fornecidas.

Exceções

ArgumentNullException

O argumento tasks foi null.

ArgumentException

A matriz tasks continha uma tarefa null.

Exemplos

O exemplo a seguir cria um conjunto de tarefas que pingam as URLs em uma matriz. As tarefas são armazenadas em uma coleção List<Task> que é convertida em uma matriz e passada para o método WhenAll(IEnumerable<Task>). Após a chamada para o método Wait garante que todos os threads tenham sido concluídos, o exemplo examinará a propriedade Task.Status para determinar se alguma tarefa falhou.

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

Comentários

As sobrecargas do método WhenAll que retornam um objeto Task normalmente são chamadas quando você está interessado no status de um conjunto de tarefas ou nas exceções geradas por um conjunto de tarefas.

Nota

A chamada para WhenAll(Task[]) método não bloqueia o thread de chamada.

Se qualquer uma das tarefas fornecidas for concluída em um estado com falha, a tarefa retornada também será concluída em um estado Faulted, em que suas exceções conterão a agregação do conjunto de exceções desembrulhadas de cada uma das tarefas fornecidas.

Se nenhuma das tarefas fornecidas falhar, mas pelo menos uma delas tiver sido cancelada, a tarefa retornada terminará no estado Canceled.

Se nenhuma das tarefas tiver falha e nenhuma das tarefas tiver sido cancelada, a tarefa resultante terminará no estado RanToCompletion.

Se a matriz/enumerável fornecida não contiver tarefas, a tarefa retornada fará a transição imediata para um estado RanToCompletion antes de ser retornada ao chamador.

Aplica-se a

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

Cria uma tarefa que será concluída quando todas as tarefas fornecidas forem concluídas.

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

Parâmetros

tasks
ReadOnlySpan<Task<TResult>>

As tarefas a serem aguardadas para conclusão.

Retornos

Task<TResult[]>

Uma tarefa que representa a conclusão de todas as tarefas fornecidas.

Exceções

ArgumentException

A matriz tasks contém uma tarefa null.

Comentários

Se qualquer uma das tarefas fornecidas for concluída em um estado com falha, a tarefa retornada também será concluída em um estado com falha, em que suas exceções conterão a agregação do conjunto de exceções desembrulhadas de cada uma das tarefas fornecidas.

Se nenhuma das tarefas fornecidas falhar, mas pelo menos uma delas tiver sido cancelada, a tarefa retornada terminará no estado Cancelado.

Se nenhuma das tarefas tiver falha e nenhuma das tarefas tiver sido cancelada, a tarefa resultante terminará no estado RanToCompletion. O resultado da tarefa retornada será definido como uma matriz que contém todos os resultados das tarefas fornecidas na mesma ordem que foram fornecidas (por exemplo, se a matriz de tarefas de entrada contiver t1, t2, t3, o Resultado da tarefa de saída retornará um TResult[] em que arr[0] == t1. Resultado, arr[1] == t2. Resultado e arr[2] == t3. Resultado).

Se a matriz/enumerável fornecida não contiver tarefas, a tarefa retornada fará a transição imediata para um estado RanToCompletion antes de ser retornada ao chamador. O TResult[] retornado será uma matriz de 0 elementos.

Aplica-se a

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

Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs

Cria uma tarefa que será concluída quando todos os objetos Task<TResult> em uma coleção enumerável forem concluídos.

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

O tipo da tarefa concluída.

Parâmetros

tasks
IEnumerable<Task<TResult>>

As tarefas a serem aguardadas para conclusão.

Retornos

Task<TResult[]>

Uma tarefa que representa a conclusão de todas as tarefas fornecidas.

Exceções

ArgumentNullException

O argumento tasks foi null.

ArgumentException

A coleção tasks continha uma tarefa null.

Exemplos

O exemplo a seguir cria dez tarefas, cada uma das quais cria um gerador de número aleatório que cria 1.000 números aleatórios entre 1 e 1.000 e calcula sua média. O método Delay(Int32) é usado para atrasar a instanciação dos geradores de número aleatório para que eles não sejam criados com valores de semente idênticos. A chamada para o método WhenAll retorna uma matriz Int64 que contém a média computada por cada tarefa. Em seguida, elas são usadas para calcular a média geral.

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

Nesse caso, as dez tarefas individuais são armazenadas em um objeto List<T>. List<T> implementa a interface IEnumerable<T>.

Comentários

A chamada para WhenAll<TResult>(IEnumerable<Task<TResult>>) método não bloqueia o thread de chamada. No entanto, uma chamada para a propriedade Result retornada bloqueia o thread de chamada.

Se qualquer uma das tarefas fornecidas for concluída em um estado com falha, a tarefa retornada também será concluída em um estado Faulted, em que suas exceções conterão a agregação do conjunto de exceções desembrulhadas de cada uma das tarefas fornecidas.

Se nenhuma das tarefas fornecidas falhar, mas pelo menos uma delas tiver sido cancelada, a tarefa retornada terminará no estado Canceled.

Se nenhuma das tarefas tiver falha e nenhuma das tarefas tiver sido cancelada, a tarefa resultante terminará no estado RanToCompletion. A propriedade Task<TResult>.Result da tarefa retornada será definida como uma matriz que contém todos os resultados das tarefas fornecidas na mesma ordem fornecida (por exemplo, se a matriz de tarefas de entrada contiver t1, t2, t3, a propriedade Task<TResult>.Result da tarefa de saída retornará um TResult[] em que arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Se o argumento tasks não contiver tarefas, a tarefa retornada fará a transição imediata para um estado RanToCompletion antes de ser retornada ao chamador. O TResult[] retornado será uma matriz de 0 elementos.

Aplica-se a

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

Origem:
Task.cs
Origem:
Task.cs
Origem:
Task.cs

Cria uma tarefa que será concluída quando todos os objetos Task<TResult> em uma matriz forem concluídos.

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

O tipo da tarefa concluída.

Parâmetros

tasks
Task<TResult>[]

As tarefas a serem aguardadas para conclusão.

Retornos

Task<TResult[]>

Uma tarefa que representa a conclusão de todas as tarefas fornecidas.

Exceções

ArgumentNullException

O argumento tasks foi null.

ArgumentException

A matriz tasks continha uma tarefa null.

Exemplos

O exemplo a seguir cria dez tarefas, cada uma das quais cria um gerador de número aleatório que cria 1.000 números aleatórios entre 1 e 1.000 e calcula sua média. Nesse caso, as dez tarefas individuais são armazenadas em uma matriz de Task<Int64>. O método Delay(Int32) é usado para atrasar a instanciação dos geradores de número aleatório para que eles não sejam criados com valores de semente idênticos. A chamada para o método WhenAll retorna uma matriz Int64 que contém a média computada por cada tarefa. Em seguida, elas são usadas para calcular a média geral.

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

Comentários

A chamada para WhenAll<TResult>(Task<TResult>[]) método não bloqueia o thread de chamada. No entanto, uma chamada para a propriedade Result retornada bloqueia o thread de chamada.

Se qualquer uma das tarefas fornecidas for concluída em um estado com falha, a tarefa retornada também será concluída em um estado Faulted, em que suas exceções conterão a agregação do conjunto de exceções desembrulhadas de cada uma das tarefas fornecidas.

Se nenhuma das tarefas fornecidas falhar, mas pelo menos uma delas tiver sido cancelada, a tarefa retornada terminará no estado Canceled.

Se nenhuma das tarefas tiver falha e nenhuma das tarefas tiver sido cancelada, a tarefa resultante terminará no estado RanToCompletion. O Result da tarefa retornada será definido como uma matriz que contém todos os resultados das tarefas fornecidas na mesma ordem que foram fornecidas (por exemplo, se a matriz de tarefas de entrada contiver t1, t2, t3, o Result da tarefa de saída retornará um TResult[] em que arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Se a matriz/enumerável fornecida não contiver tarefas, a tarefa retornada fará a transição imediata para um estado RanToCompletion antes de ser retornada ao chamador. O TResult[] retornado será uma matriz de 0 elementos.

Aplica-se a