Task.WhenAll Methode

Definition

Namespace:

System.Threading.Tasks

Assembly:

System.Runtime.dll

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

Überlädt

WhenAll(IEnumerable<Task>)	Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task Objekte in einer enumerationsfähigen Auflistung abgeschlossen sind.
WhenAll(Task[])	Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task Objekte in einem Array abgeschlossen sind.
WhenAll<TResult>(IEnumerable<Task<TResult>>)	Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult> Objekte in einer enumerationsfähigen Auflistung abgeschlossen sind.
WhenAll<TResult>(Task<TResult>[])	Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult> Objekte in einem Array abgeschlossen sind.

WhenAll(IEnumerable<Task>)

Quelle:

Task.cs

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task Objekte in einer enumerationsfähigen 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 argument tasks war null.

ArgumentException

Die tasks-Auflistung 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 bestimmen, 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 WhenAll-Methode, die ein Task-Objekt zurückgeben, werden in der Regel aufgerufen, wenn Sie an dem Status einer Gruppe von Aufgaben oder an 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 Sätze von nicht zugewiesenen Ausnahmen von jedem der bereitgestellten Vorgänge enthalten.

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

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

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

WhenAll(Task[])

Quelle:

Task.cs

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task 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 argument tasks 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 bestimmen, 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 WhenAll-Methode, die ein Task-Objekt zurückgeben, werden in der Regel aufgerufen, wenn Sie an dem Status einer Gruppe von Aufgaben oder an 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 Sätze von nicht zugewiesenen Ausnahmen von jedem der bereitgestellten Vorgänge enthalten.

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

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

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

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

Quelle:

Task.cs

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult> Objekte in einer enumerationsfähigen 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 argument tasks war null.

ArgumentException

Die tasks-Auflistung 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 Ausgangswerten erstellt werden. Der Aufruf der WhenAll-Methode gibt dann ein Int64 Array zurück, das den von den einzelnen Vorgängen 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 Sätze von nicht zugewiesenen Ausnahmen von jedem der bereitgestellten Vorgänge enthalten.

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

Wenn keine der Vorgänge fehlerhaft ist und keine 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 wie bereitgestellt enthält (z. B. wenn das Eingabeaufgabenarray t1, t2, t3 enthält, gibt die Task<TResult>.Result Eigenschaft des Ausgabevorgangs eine TResult[] zurück, wobei arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

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

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

Quelle:

Task.cs

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult> 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 argument tasks 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 Vorgänge 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 Ausgangswerten erstellt werden. Der Aufruf der WhenAll-Methode gibt dann ein Int64 Array zurück, das den von den einzelnen Vorgängen 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 Sätze von nicht zugewiesenen Ausnahmen von jedem der bereitgestellten Vorgänge enthalten.

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

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

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