Freigeben über

Task.WhenAll Methode

Definition

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

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle bereitgestellten Vorgänge abgeschlossen wurden.

Überlädt

Name Beschreibung
WhenAll(IEnumerable<Task>)

Erstellt eine Aufgabe, die Task abgeschlossen wird, wenn alle Objekte in einer aufzählbaren Auflistung abgeschlossen sind.
WhenAll(ReadOnlySpan<Task>)

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle bereitgestellten Vorgänge abgeschlossen wurden.
WhenAll(Task[])

Erstellt eine Aufgabe, die Task abgeschlossen wird, wenn alle Objekte in einem Array abgeschlossen sind.
WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle bereitgestellten Vorgänge abgeschlossen wurden.
WhenAll<TResult>(IEnumerable<Task<TResult>>)

Erstellt eine Aufgabe, die Task<TResult> abgeschlossen wird, wenn alle Objekte in einer aufzählbaren Auflistung abgeschlossen sind.
WhenAll<TResult>(Task<TResult>[])

Erstellt eine Aufgabe, die Task<TResult> abgeschlossen wird, wenn alle Objekte in einem Array abgeschlossen sind.

WhenAll(IEnumerable<Task>)

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Erstellt eine Aufgabe, die Task abgeschlossen wird, wenn alle Objekte in einer aufzählbaren Auflistung abgeschlossen sind.

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

Parameter

tasks
IEnumerable<Task>

Die Aufgaben, die auf den Abschluss warten sollen.

Gibt zurück

Task

Ein Vorgang, der den Abschluss aller bereitgestellten Vorgänge darstellt.

Ausnahmen

ArgumentNullException

Das tasks Argument war null.

ArgumentException

Die tasks Sammlung enthielt eine null Aufgabe.

Beispiele

Im folgenden Beispiel wird eine Reihe von Aufgaben erstellt, die die URLs in einem Array pingen. Die Aufgaben werden in einer List<Task> Auflistung gespeichert, die an die WhenAll(IEnumerable<Task>) Methode übergeben wird. Nachdem der Aufruf der Wait Methode sichergestellt ist, dass alle Threads abgeschlossen sind, überprüft das Beispiel die Task.Status Eigenschaft, um zu ermitteln, ob Vorgänge fehlerhaft sind.

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

Hinweise

Die Überladungen der Methode, die ein Task Objekt zurückgeben, werden in der WhenAll Regel aufgerufen, wenn Sie an dem Status einer Gruppe von Vorgängen oder in den Ausnahmen interessiert sind, die von einer Reihe von Vorgängen ausgelöst werden.

Anmerkung

Der Aufruf der WhenAll(IEnumerable<Task>) Methode blockiert nicht den aufrufenden Thread.

Wenn eine der bereitgestellten Vorgänge in einem fehlerhaften Zustand abgeschlossen wird, wird der zurückgegebene Vorgang auch in einem Faulted Zustand abgeschlossen, in dem seine Ausnahmen die Aggregation der Gruppe der nicht zugewiesenen Ausnahmen von den einzelnen bereitgestellten Vorgängen enthalten.

Wenn keine der bereitgestellten Vorgänge fehlerhaft war, aber mindestens eine davon abgebrochen wurde, endet der zurückgegebene Vorgang im Canceled Zustand.

Wenn keine der Vorgänge fehlerhaft war und keines der Vorgänge abgebrochen wurde, endet der resultierende Vorgang im RanToCompletion Zustand.

Wenn das angegebene Array/enumerable keine Vorgänge enthält, wechselt der zurückgegebene Vorgang sofort in einen RanToCompletion Zustand, bevor er an den Aufrufer zurückgegeben wird.

Gilt für:

WhenAll(ReadOnlySpan<Task>)

Quelle:
Task.cs
Quelle:
Task.cs

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle bereitgestellten Vorgänge abgeschlossen wurden.

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

Parameter

tasks
ReadOnlySpan<Task>

Die Aufgaben, die auf den Abschluss warten sollen.

Gibt zurück

Task

Ein Vorgang, der den Abschluss aller bereitgestellten Vorgänge darstellt.

Ausnahmen

ArgumentException

Das tasks Array enthält eine null Aufgabe.

Hinweise

Wenn eine der bereitgestellten Vorgänge in einem fehlerhaften Zustand abgeschlossen wird, wird der zurückgegebene Vorgang auch in einem fehlerhaften Zustand abgeschlossen, in dem seine Ausnahmen die Aggregation der Gruppe von nicht angewendeten Ausnahmen von jedem der bereitgestellten Vorgänge enthalten.

Wenn keine der bereitgestellten Vorgänge fehlerhaft war, aber mindestens eine davon abgebrochen wurde, endet der zurückgegebene Vorgang im Status "Abgebrochen".

Wenn keine der vorgänge fehlerhaft ist und keine der Vorgänge abgebrochen wurde, endet der resultierende Vorgang im Zustand "RanToCompletion".

Wenn die angegebene Spanne keine Vorgänge enthält, wechselt der zurückgegebene Vorgang sofort in einen RanToCompletion-Zustand, bevor er an den Aufrufer zurückgegeben wird.

Gilt für:

WhenAll(Task[])

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Erstellt eine Aufgabe, die Task abgeschlossen wird, wenn alle Objekte in einem Array abgeschlossen sind.

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

Parameter

tasks
Task[]

Die Aufgaben, die auf den Abschluss warten sollen.

Gibt zurück

Task

Ein Vorgang, der den Abschluss aller bereitgestellten Vorgänge darstellt.

Ausnahmen

ArgumentNullException

Das tasks Argument war null.

ArgumentException

Das tasks Array enthielt eine null Aufgabe.

Beispiele

Im folgenden Beispiel wird eine Reihe von Aufgaben erstellt, die die URLs in einem Array pingen. Die Aufgaben werden in einer List<Task> Auflistung gespeichert, die in ein Array konvertiert und an die WhenAll(IEnumerable<Task>) Methode übergeben wird. Nachdem der Aufruf der Wait Methode sichergestellt ist, dass alle Threads abgeschlossen sind, überprüft das Beispiel die Task.Status Eigenschaft, um zu ermitteln, ob Vorgänge fehlerhaft sind.

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

Hinweise

Die Überladungen der Methode, die ein Task Objekt zurückgeben, werden in der WhenAll Regel aufgerufen, wenn Sie an dem Status einer Gruppe von Vorgängen oder in den Ausnahmen interessiert sind, die von einer Reihe von Vorgängen ausgelöst werden.

Anmerkung

Der Aufruf der WhenAll(Task[]) Methode blockiert nicht den aufrufenden Thread.

Wenn eine der bereitgestellten Vorgänge in einem fehlerhaften Zustand abgeschlossen wird, wird der zurückgegebene Vorgang auch in einem Faulted Zustand abgeschlossen, in dem seine Ausnahmen die Aggregation der Gruppe der nicht zugewiesenen Ausnahmen von den einzelnen bereitgestellten Vorgängen enthalten.

Wenn keine der bereitgestellten Vorgänge fehlerhaft war, aber mindestens eine davon abgebrochen wurde, endet der zurückgegebene Vorgang im Canceled Zustand.

Wenn keine der Vorgänge fehlerhaft war und keines der Vorgänge abgebrochen wurde, endet der resultierende Vorgang im RanToCompletion Zustand.

Wenn das angegebene Array/enumerable keine Vorgänge enthält, wechselt der zurückgegebene Vorgang sofort in einen RanToCompletion Zustand, bevor er an den Aufrufer zurückgegeben wird.

Gilt für:

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

Quelle:
Task.cs
Quelle:
Task.cs

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle bereitgestellten Vorgänge abgeschlossen wurden.

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

Typparameter

TResult

Der Typ des Ergebnisses, das von den Vorgängen zurückgegeben wird.

Parameter

tasks
ReadOnlySpan<Task<TResult>>

Die Aufgaben, die auf den Abschluss warten sollen.

Gibt zurück

Task<TResult[]>

Ein Vorgang, der den Abschluss aller bereitgestellten Vorgänge darstellt.

Ausnahmen

ArgumentException

Das tasks Array enthält eine null Aufgabe.

Hinweise

Wenn eine der bereitgestellten Vorgänge in einem fehlerhaften Zustand abgeschlossen wird, wird der zurückgegebene Vorgang auch in einem fehlerhaften Zustand abgeschlossen, in dem seine Ausnahmen die Aggregation der Gruppe von nicht angewendeten Ausnahmen von jedem der bereitgestellten Vorgänge enthalten.

Wenn keine der bereitgestellten Vorgänge fehlerhaft war, aber mindestens eine davon abgebrochen wurde, endet der zurückgegebene Vorgang im Status "Abgebrochen".

Wenn keine der vorgänge fehlerhaft ist und keine der Vorgänge abgebrochen wurde, endet der resultierende Vorgang im Zustand "RanToCompletion". Das Ergebnis des zurückgegebenen Vorgangs wird auf ein Array festgelegt, das alle Ergebnisse der bereitgestellten Vorgänge in der gleichen Reihenfolge enthält wie sie angegeben wurden (z. B. wenn das Eingabeaufgabenarray t1, t2, t3 enthält, gibt das Ergebnis des Ausgabevorgangs ein TResult[] zurück, wobei arr[0] == t1. Ergebnis, arr[1] == t2. Ergebnis und Arr[2] == t3. Ergebnis).

Wenn das angegebene Array/enumerable keine Vorgänge enthält, wechselt der zurückgegebene Vorgang sofort zu einem RanToCompletion-Zustand, bevor er an den Aufrufer zurückgegeben wird. Das zurückgegebene TResult[] ist ein Array von 0 Elementen.

Gilt für:

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

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Erstellt eine Aufgabe, die Task<TResult> abgeschlossen wird, wenn alle Objekte in einer aufzählbaren Auflistung abgeschlossen sind.

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

Typparameter

TResult

Der Typ der abgeschlossenen Aufgabe.

Parameter

tasks
IEnumerable<Task<TResult>>

Die Aufgaben, die auf den Abschluss warten sollen.

Gibt zurück

Task<TResult[]>

Ein Vorgang, der den Abschluss aller bereitgestellten Vorgänge darstellt.

Ausnahmen

ArgumentNullException

Das tasks Argument war null.

ArgumentException

Die tasks Sammlung enthielt eine null Aufgabe.

Beispiele

Im folgenden Beispiel werden zehn Vorgänge erstellt, von denen jeder einen Zufallszahlengenerator instanziiert, der 1.000 Zufallszahlen zwischen 1 und 1.000 erstellt und deren Mittelwert berechnet. Die Delay(Int32) Methode wird verwendet, um die Instanziierung der Zufallszahlengeneratoren zu verzögern, sodass sie nicht mit identischen Seedwerten erstellt werden. Der Aufruf der WhenAll Methode gibt dann ein Int64 Array zurück, das den von jedem Vorgang berechneten Mittelwert enthält. Diese werden dann verwendet, um den Gesamtmittelwert zu berechnen.

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

In diesem Fall werden die zehn einzelnen Aufgaben in einem List<T> Objekt gespeichert. List<T> implementiert die IEnumerable<T> Schnittstelle.

Hinweise

Der Aufruf der WhenAll<TResult>(IEnumerable<Task<TResult>>) Methode blockiert nicht den aufrufenden Thread. Ein Aufruf der zurückgegebenen Result Eigenschaft blockiert jedoch den aufrufenden Thread.

Wenn eine der bereitgestellten Vorgänge in einem fehlerhaften Zustand abgeschlossen wird, wird der zurückgegebene Vorgang auch in einem Faulted Zustand abgeschlossen, in dem seine Ausnahmen die Aggregation der Gruppe der nicht zugewiesenen Ausnahmen von den einzelnen bereitgestellten Vorgängen enthalten.

Wenn keine der bereitgestellten Vorgänge fehlerhaft war, aber mindestens eine davon abgebrochen wurde, endet der zurückgegebene Vorgang im Canceled Zustand.

Wenn keine der Vorgänge fehlerhaft war und keines der Vorgänge abgebrochen wurde, endet der resultierende Vorgang im RanToCompletion Zustand. Die Task<TResult>.Result Eigenschaft des zurückgegebenen Vorgangs wird auf ein Array festgelegt, das alle Ergebnisse der bereitgestellten Vorgänge in der gleichen Reihenfolge enthält, wie sie angegeben wurden (z. B. wenn das Eingabeaufgabenarray t1, t2, t3 enthielt, gibt die Eigenschaft des Ausgabevorgangs Task<TResult>.Result eine TResult[] Stelle arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result)zurück.

Wenn das tasks Argument keine Vorgänge enthält, wechselt der zurückgegebene Vorgang sofort in einen RanToCompletion Zustand, bevor es an den Aufrufer zurückgegeben wird. Das zurückgegebene TResult[] Element ist ein Array von 0 Elementen.

Gilt für:

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

Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs
Quelle:
Task.cs

Erstellt eine Aufgabe, die Task<TResult> abgeschlossen wird, wenn alle Objekte in einem Array abgeschlossen sind.

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

Typparameter

TResult

Der Typ der abgeschlossenen Aufgabe.

Parameter

tasks
Task<TResult>[]

Die Aufgaben, die auf den Abschluss warten sollen.

Gibt zurück

Task<TResult[]>

Ein Vorgang, der den Abschluss aller bereitgestellten Vorgänge darstellt.

Ausnahmen

ArgumentNullException

Das tasks Argument war null.

ArgumentException

Das tasks Array enthielt eine null Aufgabe.

Beispiele

Im folgenden Beispiel werden zehn Vorgänge erstellt, von denen jeder einen Zufallszahlengenerator instanziiert, der 1.000 Zufallszahlen zwischen 1 und 1.000 erstellt und deren Mittelwert berechnet. In diesem Fall werden die zehn einzelnen Aufgaben in einem Task<Int64> Array gespeichert. Die Delay(Int32) Methode wird verwendet, um die Instanziierung der Zufallszahlengeneratoren zu verzögern, sodass sie nicht mit identischen Seedwerten erstellt werden. Der Aufruf der WhenAll Methode gibt dann ein Int64 Array zurück, das den von jedem Vorgang berechneten Mittelwert enthält. Diese werden dann verwendet, um den Gesamtmittelwert zu berechnen.

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

Hinweise

Der Aufruf der WhenAll<TResult>(Task<TResult>[]) Methode blockiert nicht den aufrufenden Thread. Ein Aufruf der zurückgegebenen Result Eigenschaft blockiert jedoch den aufrufenden Thread.

Wenn eine der bereitgestellten Vorgänge in einem fehlerhaften Zustand abgeschlossen wird, wird der zurückgegebene Vorgang auch in einem Faulted Zustand abgeschlossen, in dem seine Ausnahmen die Aggregation der Gruppe der nicht zugewiesenen Ausnahmen von den einzelnen bereitgestellten Vorgängen enthalten.

Wenn keine der bereitgestellten Vorgänge fehlerhaft war, aber mindestens eine davon abgebrochen wurde, endet der zurückgegebene Vorgang im Canceled Zustand.

Wenn keine der Vorgänge fehlerhaft war und keines der Vorgänge abgebrochen wurde, endet der resultierende Vorgang im RanToCompletion Zustand. Der Result zurückgegebene Vorgang wird auf ein Array festgelegt, das alle Ergebnisse der bereitgestellten Vorgänge in der gleichen Reihenfolge enthält, wie sie angegeben wurden (z. B. wenn das Eingabeaufgabenarray t1, t2, t3 enthielt, gibt die Ausgabeaufgabe Result eine TResult[] Stelle arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result)zurück.

Wenn das angegebene Array/enumerable keine Vorgänge enthält, wechselt der zurückgegebene Vorgang sofort in einen RanToCompletion Zustand, bevor er an den Aufrufer zurückgegeben wird. Das zurückgegebene TResult[] Element ist ein Array von 0 Elementen.

Gilt für: