Sdílet prostřednictvím

Task.WhenAll Metoda

  • Reference

Definice

Obor názvů:
System.Threading.Tasks
Sestavení:
System.Threading.Tasks.dll
Sestavení:
System.Runtime.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll

Vytvoří úkol, který se dokončí po dokončení všech zadaných úkolů.

Přetížení

WhenAll(IEnumerable<Task>)

Vytvoří úlohu, která se dokončí, když se dokončí všechny Task objekty v výčtové kolekci.
WhenAll(ReadOnlySpan<Task>)

Vytvoří úkol, který se dokončí po dokončení všech zadaných úkolů.
WhenAll(Task[])

Vytvoří úlohu, která se dokončí, když se dokončí všechny Task objekty v poli.
WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)

Vytvoří úkol, který se dokončí po dokončení všech zadaných úkolů.
WhenAll<TResult>(IEnumerable<Task<TResult>>)

Vytvoří úlohu, která se dokončí, když se dokončí všechny Task<TResult> objekty v výčtové kolekci.
WhenAll<TResult>(Task<TResult>[])

Vytvoří úlohu, která se dokončí, když se dokončí všechny Task<TResult> objekty v poli.

WhenAll(IEnumerable<Task>)

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří úlohu, která se dokončí, když se dokončí všechny Task objekty v výčtové kolekci.

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

Parametry

tasks
IEnumerable<Task>

Úkoly, které mají čekat na dokončení.

Návraty

Task

Úkol, který představuje dokončení všech zadaných úkolů.

Výjimky

ArgumentNullException

Argument tasks byl null.

ArgumentException

Kolekce tasks obsahovala úlohu null.

Příklady

Následující příklad vytvoří sadu úloh, které ping adresy URL v poli. Úlohy jsou uloženy v kolekci List<Task>, která je předána metodě WhenAll(IEnumerable<Task>). Po volání Wait metoda zajišťuje, že všechna vlákna byla dokončena, příklad prozkoumá Task.Status vlastnost určit, zda některé úlohy byly chybné.

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

Poznámky

Přetížení WhenAll metody, která vrací objekt Task jsou obvykle volány, pokud vás zajímá stav sady úkolů nebo výjimky vyvolané sadou úkolů.

Poznámka

Volání metody WhenAll(IEnumerable<Task>) neblokuje volající vlákno.

Pokud některý z zadaných úkolů skončí v chybném stavu, vrácený úkol se dokončí také v Faulted stavu, kde jeho výjimky budou obsahovat agregaci sady nezabalených výjimek z každého zadaného úkolu.

Pokud žádný z zadaných úkolů nebyl chybný, ale alespoň jeden z nich byl zrušen, vrácený úkol skončí v Canceled stavu.

Pokud se žádný z úkolů nevyrušil a žádný z úkolů nebyl zrušen, výsledný úkol skončí ve stavu RanToCompletion.

Pokud zadané pole nebo výčet neobsahuje žádné úkoly, vrácený úkol okamžitě přejde do RanToCompletion stavu, než se vrátí volajícímu.

Platí pro

WhenAll(ReadOnlySpan<Task>)

Vytvoří úkol, který se dokončí po dokončení všech zadaných úkolů.

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

Parametry

tasks
ReadOnlySpan<Task>

Úkoly, které mají čekat na dokončení.

Návraty

Task

Úkol, který představuje dokončení všech zadaných úkolů.

Výjimky

ArgumentException

Pole tasks obsahuje null úkol.

Poznámky

Pokud se některý z zadaných úkolů dokončí v chybném stavu, vrácený úkol se dokončí také ve stavu Selhání, kde jeho výjimky budou obsahovat agregaci sady nezapsaných výjimek z každého zadaného úkolu.

Pokud žádný z zadaných úkolů nebyl chybný, ale alespoň jeden z nich byl zrušen, vrácený úkol skončí ve stavu Zrušeno.

Pokud žádný z úkolů nebyl chybován a žádný z úkolů nebyl zrušen, výsledný úkol skončí ve stavu RanToCompletion.

Pokud zadané rozsah neobsahuje žádné úkoly, vrácený úkol okamžitě přejde do stavu RanToCompletion, než se vrátí volajícímu.

Platí pro

WhenAll(Task[])

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří úlohu, která se dokončí, když se dokončí všechny Task objekty v poli.

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

Parametry

tasks
Task[]

Úkoly, které mají čekat na dokončení.

Návraty

Task

Úkol, který představuje dokončení všech zadaných úkolů.

Výjimky

ArgumentNullException

Argument tasks byl null.

ArgumentException

Pole tasks obsahovalo null úkol.

Příklady

Následující příklad vytvoří sadu úloh, které ping adresy URL v poli. Úlohy jsou uloženy v List<Task> kolekci, která je převedena na pole a předána do WhenAll(IEnumerable<Task>) metody. Po volání Wait metoda zajišťuje, že všechna vlákna byla dokončena, příklad prozkoumá Task.Status vlastnost určit, zda některé úlohy byly chybné.

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

Poznámky

Přetížení WhenAll metody, která vrací objekt Task jsou obvykle volány, pokud vás zajímá stav sady úkolů nebo výjimky vyvolané sadou úkolů.

Poznámka

Volání metody WhenAll(Task[]) neblokuje volající vlákno.

Pokud některý z zadaných úkolů skončí v chybném stavu, vrácený úkol se dokončí také v Faulted stavu, kde jeho výjimky budou obsahovat agregaci sady nezabalených výjimek z každého zadaného úkolu.

Pokud žádný z zadaných úkolů nebyl chybný, ale alespoň jeden z nich byl zrušen, vrácený úkol skončí v Canceled stavu.

Pokud se žádný z úkolů nevyrušil a žádný z úkolů nebyl zrušen, výsledný úkol skončí ve stavu RanToCompletion.

Pokud zadané pole nebo výčet neobsahuje žádné úkoly, vrácený úkol okamžitě přejde do RanToCompletion stavu, než se vrátí volajícímu.

Platí pro

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

Vytvoří úkol, který se dokončí po dokončení všech zadaných úkolů.

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

Parametry typu

TResult

Parametry

tasks
ReadOnlySpan<Task<TResult>>

Úkoly, které mají čekat na dokončení.

Návraty

Task<TResult[]>

Úkol, který představuje dokončení všech zadaných úkolů.

Výjimky

ArgumentException

Pole tasks obsahuje null úkol.

Poznámky

Pokud se některý z zadaných úkolů dokončí v chybném stavu, vrácený úkol se dokončí také ve stavu Selhání, kde jeho výjimky budou obsahovat agregaci sady nezapsaných výjimek z každého zadaného úkolu.

Pokud žádný z zadaných úkolů nebyl chybný, ale alespoň jeden z nich byl zrušen, vrácený úkol skončí ve stavu Zrušeno.

Pokud žádný z úkolů nebyl chybován a žádný z úkolů nebyl zrušen, výsledný úkol skončí ve stavu RanToCompletion. Výsledek vráceného úkolu se nastaví na pole obsahující všechny výsledky zadaných úkolů ve stejném pořadí, v jakém byly zadány (například pokud vstupní pole úkolů obsahovalo t1, t2, t3, výsledek výstupního úkolu vrátí výsledek TResult[] kde arr[0] == t1. Výsledek, arr[1] == t2. Výsledek a arr[2] == t3. Výsledek).

Pokud zadané pole nebo výčet neobsahuje žádné úkoly, vrácený úkol okamžitě přejde do stavu RanToCompletion, než se vrátí volajícímu. Vrácený TResult[] bude pole 0 prvků.

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří úlohu, která se dokončí, když se dokončí všechny Task<TResult> objekty v výčtové kolekci.

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

Parametry typu

TResult

Typ dokončeného úkolu.

Parametry

tasks
IEnumerable<Task<TResult>>

Úkoly, které mají čekat na dokončení.

Návraty

Task<TResult[]>

Úkol, který představuje dokončení všech zadaných úkolů.

Výjimky

ArgumentNullException

Argument tasks byl null.

ArgumentException

Kolekce tasks obsahovala úlohu null.

Příklady

Následující příklad vytvoří deset úloh, z nichž každý vytvoří instanci generátoru náhodných čísel, který vytvoří 1 000 náhodných čísel mezi 1 a 1 000 a vypočítá jejich střední hodnotu. Metoda Delay(Int32) slouží ke zpoždění vytváření instancí generátorů náhodných čísel tak, aby nebyly vytvořeny s identickými počátečními hodnotami. Volání metody WhenAll pak vrátí pole Int64 obsahující střední hodnotu vypočítanou jednotlivými úlohami. Ty se pak používají k výpočtu celkové střední hodnoty.

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

V tomto případě jsou deset jednotlivých úkolů uloženy v List<T> objektu. List<T> implementuje rozhraní IEnumerable<T>.

Poznámky

Volání metody WhenAll<TResult>(IEnumerable<Task<TResult>>) neblokuje volající vlákno. Volání vrácené Result vlastnost však blokuje volající vlákno.

Pokud některý z zadaných úkolů skončí v chybném stavu, vrácený úkol se dokončí také v Faulted stavu, kde jeho výjimky budou obsahovat agregaci sady nezabalených výjimek z každého zadaného úkolu.

Pokud žádný z zadaných úkolů nebyl chybný, ale alespoň jeden z nich byl zrušen, vrácený úkol skončí v Canceled stavu.

Pokud se žádný z úkolů nevyrušil a žádný z úkolů nebyl zrušen, výsledný úkol skončí ve stavu RanToCompletion. Vlastnost Task<TResult>.Result vráceného úkolu bude nastavena na pole obsahující všechny výsledky zadaných úkolů ve stejném pořadí, v jakém byly zadány (například pokud vstupní pole úkolů obsahovalo t1, t2, t3, vlastnost Task<TResult>.Result výstupního úkolu vrátí TResult[], kde arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Pokud argument tasks neobsahuje žádné úkoly, vrácený úkol okamžitě přejde do RanToCompletion stavu, než se vrátí volajícímu. Vrácená TResult[] bude pole 0 prvků.

Platí pro

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

Zdroj:
Task.cs
Zdroj:
Task.cs
Zdroj:
Task.cs

Vytvoří úlohu, která se dokončí, když se dokončí všechny Task<TResult> objekty v poli.

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

Parametry typu

TResult

Typ dokončeného úkolu.

Parametry

tasks
Task<TResult>[]

Úkoly, které mají čekat na dokončení.

Návraty

Task<TResult[]>

Úkol, který představuje dokončení všech zadaných úkolů.

Výjimky

ArgumentNullException

Argument tasks byl null.

ArgumentException

Pole tasks obsahovalo null úkol.

Příklady

Následující příklad vytvoří deset úloh, z nichž každý vytvoří instanci generátoru náhodných čísel, který vytvoří 1 000 náhodných čísel mezi 1 a 1 000 a vypočítá jejich střední hodnotu. V tomto případě jsou deset jednotlivých úkolů uloženy v poli Task<Int64>. Metoda Delay(Int32) slouží ke zpoždění vytváření instancí generátorů náhodných čísel tak, aby nebyly vytvořeny s identickými počátečními hodnotami. Volání metody WhenAll pak vrátí pole Int64 obsahující střední hodnotu vypočítanou jednotlivými úlohami. Ty se pak používají k výpočtu celkové střední hodnoty.

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

Poznámky

Volání metody WhenAll<TResult>(Task<TResult>[]) neblokuje volající vlákno. Volání vrácené Result vlastnost však blokuje volající vlákno.

Pokud některý z zadaných úkolů skončí v chybném stavu, vrácený úkol se dokončí také v Faulted stavu, kde jeho výjimky budou obsahovat agregaci sady nezabalených výjimek z každého zadaného úkolu.

Pokud žádný z zadaných úkolů nebyl chybný, ale alespoň jeden z nich byl zrušen, vrácený úkol skončí v Canceled stavu.

Pokud se žádný z úkolů nevyrušil a žádný z úkolů nebyl zrušen, výsledný úkol skončí ve stavu RanToCompletion. Result vráceného úkolu se nastaví na pole obsahující všechny výsledky zadaných úkolů ve stejném pořadí, v jakém byly zadány (například pokud vstupní pole úkolů obsahovalo t1, t2, t3, Result výstupního úkolu vrátí TResult[], kde arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Pokud zadané pole nebo výčet neobsahuje žádné úkoly, vrácený úkol okamžitě přejde do RanToCompletion stavu, než se vrátí volajícímu. Vrácená TResult[] bude pole 0 prvků.

Platí pro