Task.WhenAll Metoda

Definicja

Przestrzeń nazw:

System.Threading.Tasks

Zestawy:

netstandard.dll, System.Runtime.dll

Tworzy zadanie, które zostanie wykonane po zakończeniu wszystkich dostarczonych zadań.

Przeciążenia

Nazwa	Opis
WhenAll(IEnumerable<Task>)	Tworzy zadanie, które zostanie ukończone po zakończeniu Task wszystkich obiektów w kolekcji wyliczalnej.
WhenAll(ReadOnlySpan<Task>)	Tworzy zadanie, które zostanie wykonane po zakończeniu wszystkich dostarczonych zadań.
WhenAll(Task[])	Tworzy zadanie, które zostanie ukończone po zakończeniu Task wszystkich obiektów w tablicy.
WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)	Tworzy zadanie, które zostanie wykonane po zakończeniu wszystkich dostarczonych zadań.
WhenAll<TResult>(IEnumerable<Task<TResult>>)	Tworzy zadanie, które zostanie ukończone po zakończeniu Task<TResult> wszystkich obiektów w kolekcji wyliczalnej.
WhenAll<TResult>(Task<TResult>[])	Tworzy zadanie, które zostanie ukończone po zakończeniu Task<TResult> wszystkich obiektów w tablicy.

WhenAll(IEnumerable<Task>)

Źródło:

Task.cs

Tworzy zadanie, które zostanie ukończone po zakończeniu Task wszystkich obiektów w kolekcji wyliczalnej.

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>

Zadania do oczekiwania na ukończenie.

Zwraca

Task

Zadanie reprezentujące ukończenie wszystkich dostarczonych zadań.

Wyjątki

ArgumentNullException

Argumentem tasks był null.

ArgumentException

Kolekcja tasks zawierała null zadanie.

Przykłady

Poniższy przykład tworzy zestaw zadań, które wysyłają polecenia ping do adresów URL w tablicy. Zadania są przechowywane w List<Task> kolekcji przekazywanej WhenAll(IEnumerable<Task>) do metody . Po wywołaniu Wait metody gwarantuje, że wszystkie wątki zostały ukończone, przykład analizuje Task.Status właściwość w celu określenia, czy jakiekolwiek zadania zostały uszkodzone.

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

Uwagi

Przeciążenia WhenAll metody zwracającej Task obiekt są zwykle wywoływane, gdy interesuje Cię stan zestawu zadań lub wyjątków zgłaszanych przez zestaw zadań.

Nuta

Wywołanie WhenAll(IEnumerable<Task>) metody nie blokuje wątku wywołującego.

Jeśli którekolwiek z podanych zadań zostanie ukończone w stanie uszkodzonym, zwrócone zadanie zostanie również ukończone w Faulted stanie, w którym jego wyjątki będą zawierać agregację zestawu nieprzypisanych wyjątków od każdego z dostarczonych zadań.

Jeśli żadne z podanych zadań nie zostało uszkodzone, ale co najmniej jedno z nich zostało anulowane, zwrócone zadanie zakończy się w Canceled stanie .

Jeśli żadne z zadań nie zostało uszkodzone i żadne z zadań nie zostały anulowane, wynikowe zadanie zakończy się w RanToCompletion stanie .

Jeśli podana tablica/wyliczenie nie zawiera żadnych zadań, zwrócone zadanie natychmiast przejdzie do RanToCompletion stanu, zanim zostanie zwrócone do obiektu wywołującego.

WhenAll(ReadOnlySpan<Task>)

Źródło:

Task.cs

Tworzy zadanie, które zostanie wykonane po zakończeniu wszystkich dostarczonych zadań.

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>

Zadania do oczekiwania na ukończenie.

Zwraca

Task

Zadanie reprezentujące ukończenie wszystkich dostarczonych zadań.

Wyjątki

ArgumentException

Tablica tasks zawiera null zadanie.

Uwagi

Jeśli którekolwiek z podanych zadań zostanie ukończone w stanie uszkodzonym, zwrócone zadanie zostanie również ukończone w stanie Uszkodzony, gdzie jego wyjątki będą zawierać agregację zestawu nieprzypisanych wyjątków od każdego z dostarczonych zadań.

Jeśli żadne z podanych zadań nie zostało uszkodzone, ale co najmniej jedno z nich zostało anulowane, zwrócone zadanie zakończy się w stanie Anulowane.

Jeśli żadne z zadań nie zostało uszkodzone i żadne z zadań nie zostały anulowane, wynikowe zadanie zakończy się w stanie RanToCompletion.

Jeśli podany zakres nie zawiera żadnych zadań, zwrócone zadanie natychmiast przejdzie do stanu RanToCompletion, zanim zostanie zwrócone do elementu wywołującego.

WhenAll(Task[])

Źródło:

Task.cs

Tworzy zadanie, które zostanie ukończone po zakończeniu Task wszystkich obiektów w tablicy.

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

Zadania do oczekiwania na ukończenie.

Zwraca

Task

Zadanie reprezentujące ukończenie wszystkich dostarczonych zadań.

Wyjątki

ArgumentNullException

Argumentem tasks był null.

ArgumentException

Tablica tasks zawierała null zadanie.

Przykłady

Poniższy przykład tworzy zestaw zadań, które wysyłają polecenia ping do adresów URL w tablicy. Zadania są przechowywane w List<Task> kolekcji konwertowanej na tablicę i przekazywane do WhenAll(IEnumerable<Task>) metody . Po wywołaniu Wait metody gwarantuje, że wszystkie wątki zostały ukończone, przykład analizuje Task.Status właściwość w celu określenia, czy jakiekolwiek zadania zostały uszkodzone.

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

Uwagi

Przeciążenia WhenAll metody zwracającej Task obiekt są zwykle wywoływane, gdy interesuje Cię stan zestawu zadań lub wyjątków zgłaszanych przez zestaw zadań.

Nuta

Wywołanie WhenAll(Task[]) metody nie blokuje wątku wywołującego.

Jeśli którekolwiek z podanych zadań zostanie ukończone w stanie uszkodzonym, zwrócone zadanie zostanie również ukończone w Faulted stanie, w którym jego wyjątki będą zawierać agregację zestawu nieprzypisanych wyjątków od każdego z dostarczonych zadań.

Jeśli żadne z podanych zadań nie zostało uszkodzone, ale co najmniej jedno z nich zostało anulowane, zwrócone zadanie zakończy się w Canceled stanie .

Jeśli żadne z zadań nie zostało uszkodzone i żadne z zadań nie zostały anulowane, wynikowe zadanie zakończy się w RanToCompletion stanie .

Jeśli podana tablica/wyliczenie nie zawiera żadnych zadań, zwrócone zadanie natychmiast przejdzie do RanToCompletion stanu, zanim zostanie zwrócone do obiektu wywołującego.

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

Źródło:

Task.cs

Tworzy zadanie, które zostanie wykonane po zakończeniu wszystkich dostarczonych zadań.

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

Typ wyniku zwróconego przez zadania.

Parametry

tasks

ReadOnlySpan<Task<TResult>>

Zadania do oczekiwania na ukończenie.

Zwraca

Task<TResult[]>

Zadanie reprezentujące ukończenie wszystkich dostarczonych zadań.

Wyjątki

ArgumentException

Tablica tasks zawiera null zadanie.

Uwagi

Jeśli którekolwiek z podanych zadań zostanie ukończone w stanie uszkodzonym, zwrócone zadanie zostanie również ukończone w stanie Uszkodzony, gdzie jego wyjątki będą zawierać agregację zestawu nieprzypisanych wyjątków od każdego z dostarczonych zadań.

Jeśli żadne z podanych zadań nie zostało uszkodzone, ale co najmniej jedno z nich zostało anulowane, zwrócone zadanie zakończy się w stanie Anulowane.

Jeśli żadne z zadań nie zostało uszkodzone i żadne z zadań nie zostały anulowane, wynikowe zadanie zakończy się w stanie RanToCompletion. Wynik zwróconego zadania zostanie ustawiony na tablicę zawierającą wszystkie wyniki dostarczonych zadań w takiej samej kolejności, jak zostały podane (np. jeśli tablica zadań wejściowych zawiera t1, t2, t3, wynik zadania wyjściowego zwróci wynik TResult[] gdzie arr[0] == t1. Wynik, arr[1] == t2. Wynik i arr[2] == t3. Wynik).

Jeśli podana tablica/wyliczenie nie zawiera żadnych zadań, zwrócone zadanie natychmiast przejdzie do stanu RanToCompletion przed zwróceniem do obiektu wywołującego. Zwrócony element TResult[] będzie tablicą z 0 elementami.

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

Źródło:

Task.cs

Tworzy zadanie, które zostanie ukończone po zakończeniu Task<TResult> wszystkich obiektów w kolekcji wyliczalnej.

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 ukończonego zadania.

Parametry

tasks

IEnumerable<Task<TResult>>

Zadania do oczekiwania na ukończenie.

Zwraca

Task<TResult[]>

Zadanie reprezentujące ukończenie wszystkich dostarczonych zadań.

Wyjątki

ArgumentNullException

Argumentem tasks był null.

ArgumentException

Kolekcja tasks zawierała null zadanie.

Przykłady

Poniższy przykład tworzy dziesięć zadań, z których każdy tworzy wystąpienie generatora liczb losowych, który tworzy 1000 losowych liczb z zakresu od 1 do 1000 i oblicza ich średnią. Metoda Delay(Int32) służy do opóźniania tworzenia wystąpień generatorów liczb losowych, aby nie były tworzone z identycznymi wartościami inicjacji. Wywołanie WhenAll metody zwraca następnie tablicę zawierającą średnią obliczoną Int64 przez każde zadanie. Są one następnie używane do obliczenia ogólnej średniej.

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

W tym przypadku dziesięć pojedynczych zadań jest przechowywanych w List<T> obiekcie. List<T> implementuje IEnumerable<T> interfejs.

Uwagi

Wywołanie WhenAll<TResult>(IEnumerable<Task<TResult>>) metody nie blokuje wątku wywołującego. Jednak wywołanie zwróconej Result właściwości blokuje wątek wywołujący.

Jeśli którekolwiek z podanych zadań zostanie ukończone w stanie uszkodzonym, zwrócone zadanie zostanie również ukończone w Faulted stanie, w którym jego wyjątki będą zawierać agregację zestawu nieprzypisanych wyjątków od każdego z dostarczonych zadań.

Jeśli żadne z podanych zadań nie zostało uszkodzone, ale co najmniej jedno z nich zostało anulowane, zwrócone zadanie zakończy się w Canceled stanie .

Jeśli żadne z zadań nie zostało uszkodzone i żadne z zadań nie zostały anulowane, wynikowe zadanie zakończy się w RanToCompletion stanie . Właściwość Task<TResult>.Result zwróconego zadania zostanie ustawiona na tablicę zawierającą wszystkie wyniki dostarczonych zadań w tej samej kolejności, w której zostały podane (np. jeśli tablica zadań wejściowych zawiera t1, t2, t3, właściwość zadania Task<TResult>.Result wyjściowego zwróci TResult[] element , gdzie arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

tasks Jeśli argument nie zawiera żadnych zadań, zwrócone zadanie natychmiast przejdzie do stanu, zanim zostanie zwrócone do RanToCompletion elementu wywołującego. Zwrócona TResult[] wartość będzie tablicą z 0 elementami.

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

Źródło:

Task.cs

Tworzy zadanie, które zostanie ukończone po zakończeniu Task<TResult> wszystkich obiektów w tablicy.

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 ukończonego zadania.

Parametry

tasks

Task<TResult>[]

Zadania do oczekiwania na ukończenie.

Zwraca

Task<TResult[]>

Zadanie reprezentujące ukończenie wszystkich dostarczonych zadań.

Wyjątki

ArgumentNullException

Argumentem tasks był null.

ArgumentException

Tablica tasks zawierała null zadanie.

Przykłady

Poniższy przykład tworzy dziesięć zadań, z których każdy tworzy wystąpienie generatora liczb losowych, który tworzy 1000 losowych liczb z zakresu od 1 do 1000 i oblicza ich średnią. W tym przypadku dziesięć pojedynczych zadań jest przechowywanych w tablicy Task<Int64> . Metoda Delay(Int32) służy do opóźniania tworzenia wystąpień generatorów liczb losowych, aby nie były tworzone z identycznymi wartościami inicjacji. Wywołanie WhenAll metody zwraca następnie tablicę zawierającą średnią obliczoną Int64 przez każde zadanie. Są one następnie używane do obliczenia ogólnej średniej.

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

Uwagi

Wywołanie WhenAll<TResult>(Task<TResult>[]) metody nie blokuje wątku wywołującego. Jednak wywołanie zwróconej Result właściwości blokuje wątek wywołujący.

Jeśli którekolwiek z podanych zadań zostanie ukończone w stanie uszkodzonym, zwrócone zadanie zostanie również ukończone w Faulted stanie, w którym jego wyjątki będą zawierać agregację zestawu nieprzypisanych wyjątków od każdego z dostarczonych zadań.

Jeśli żadne z podanych zadań nie zostało uszkodzone, ale co najmniej jedno z nich zostało anulowane, zwrócone zadanie zakończy się w Canceled stanie .

Jeśli żadne z zadań nie zostało uszkodzone i żadne z zadań nie zostały anulowane, wynikowe zadanie zakończy się w RanToCompletion stanie . Zwrócone Result zadanie zostanie ustawione na tablicę zawierającą wszystkie wyniki dostarczonych zadań w takiej samej kolejności, jak zostały podane (np. jeśli tablica zadań wejściowych zawiera t1, t2, t3, zadanie Result wyjściowe zwróci element, w którym arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).TResult[]

Jeśli podana tablica/wyliczenie nie zawiera żadnych zadań, zwrócone zadanie natychmiast przejdzie do RanToCompletion stanu, zanim zostanie zwrócone do obiektu wywołującego. Zwrócona TResult[] wartość będzie tablicą z 0 elementami.