Task.WhenAll Methode

  • Referenz

Definition

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

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle angegebenen Aufgaben abgeschlossen sind.

Überlädt

WhenAll(IEnumerable<Task>)

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einer aufzählbaren Sammlung 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 aufzählbaren Sammlung 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>)

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einer aufzählbaren Sammlung 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, auf deren Abschluss gewartet werden soll.

Gibt zurück

Task

Eine Aufgabe, die den Abschluss aller angegebenen Aufgaben darstellt.

Ausnahmen

ArgumentNullException

Das tasks-Argument lautete null.

ArgumentException

Die tasks-Auflistung enthält eine null-Aufgabe.

Beispiele

Im folgenden Beispiel wird eine Reihe von Aufgaben erstellt, die die URLs in einem Array anpingen. 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 hat, dass alle Threads abgeschlossen sind, wird im Beispiel die Task.Status -Eigenschaft untersucht, um zu ermitteln, ob Bei Vorgängen ein Fehler aufgetreten ist.

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 WhenAll ein Task -Objekt zurückgibt, werden in der Regel aufgerufen, wenn Sie am Status einer Gruppe von Aufgaben oder an den Ausnahmen interessiert sind, die von einer Gruppe von Aufgaben ausgelöst werden.

Hinweis

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

Wenn eine der bereitgestellten Aufgaben in einem fehlerhaften Zustand abgeschlossen wird, wird die zurückgegebene Aufgabe auch in einem Faulted Zustand abgeschlossen, in dem die Ausnahmen die Aggregation der Gruppe der unverpackten Ausnahmen aus den einzelnen bereitgestellten Aufgaben enthalten.

Wenn keine der angegebenen Aufgaben 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 Aufgaben abgebrochen wurde, endet die resultierende Aufgabe im RanToCompletion Zustand.

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

Gilt für:

WhenAll(Task[])

Source:
Task.cs
Source:
Task.cs
Source:
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, auf deren Abschluss gewartet werden soll.

Gibt zurück

Task

Eine Aufgabe, die den Abschluss aller angegebenen Aufgaben darstellt.

Ausnahmen

ArgumentNullException

Das tasks-Argument lautete 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 anpingen. 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 hat, dass alle Threads abgeschlossen sind, wird im Beispiel die Task.Status -Eigenschaft untersucht, um zu ermitteln, ob Bei Vorgängen ein Fehler aufgetreten ist.

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 WhenAll ein Task -Objekt zurückgibt, werden in der Regel aufgerufen, wenn Sie am Status einer Gruppe von Aufgaben oder an den Ausnahmen interessiert sind, die von einer Gruppe von Aufgaben ausgelöst werden.

Hinweis

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

Wenn eine der bereitgestellten Aufgaben in einem fehlerhaften Zustand abgeschlossen wird, wird die zurückgegebene Aufgabe auch in einem Faulted Zustand abgeschlossen, in dem die Ausnahmen die Aggregation der Gruppe der unverpackten Ausnahmen aus den einzelnen bereitgestellten Aufgaben enthalten.

Wenn keine der angegebenen Aufgaben 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 Aufgaben abgebrochen wurde, endet die resultierende Aufgabe im RanToCompletion Zustand.

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

Gilt für:

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

Source:
Task.cs
Source:
Task.cs
Source:
Task.cs

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult>-Objekte in einer aufzählbaren Sammlung 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, auf deren Abschluss gewartet werden soll.

Gibt zurück

Task<TResult[]>

Eine Aufgabe, die den Abschluss aller angegebenen Aufgaben darstellt.

Ausnahmen

ArgumentNullException

Das tasks-Argument lautete null.

ArgumentException

Die tasks-Auflistung enthält eine null-Aufgabe.

Beispiele

Im folgenden Beispiel werden zehn Aufgaben erstellt, von denen jede 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 Startwerten erstellt werden. Der Aufruf der WhenAll -Methode gibt dann ein Int64 Array zurück, das den Mittelwert enthält, der von jeder Aufgabe berechnet wird. Diese werden dann zur Berechnung des Gesamtmittelwerts verwendet.

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 den aufrufenden Thread nicht. Ein Aufruf der zurückgegebenen Result Eigenschaft blockiert jedoch den aufrufenden Thread.

Wenn eine der bereitgestellten Aufgaben in einem fehlerhaften Zustand abgeschlossen wird, wird die zurückgegebene Aufgabe auch in einem Faulted Zustand abgeschlossen, in dem die Ausnahmen die Aggregation der Gruppe der unverpackten Ausnahmen aus den einzelnen bereitgestellten Aufgaben enthalten.

Wenn keine der angegebenen Aufgaben 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 Aufgaben abgebrochen wurde, endet die resultierende Aufgabe im RanToCompletion Zustand. Die Task<TResult>.Result -Eigenschaft der zurückgegebenen Aufgabe wird auf ein Array festgelegt, das alle Ergebnisse der bereitgestellten Aufgaben in der gleichen Reihenfolge enthält, in der sie bereitgestellt wurden (z. B. wenn das Eingabeaufgabenarray t1, t2, t3 enthält, gibt die -Eigenschaft des Task<TResult>.Result Ausgabetasks ein TResult[] zurück.arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result)

Wenn das tasks Argument keine Aufgaben enthält, wechselt die zurückgegebene Aufgabe sofort in einen RanToCompletion Zustand, bevor sie an den Aufrufer zurückgegeben wird. Das zurückgegebene TResult[] ist ein Array von 0 Elementen.

Gilt für:

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

Source:
Task.cs
Source:
Task.cs
Source:
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, auf deren Abschluss gewartet werden soll.

Gibt zurück

Task<TResult[]>

Eine Aufgabe, die den Abschluss aller angegebenen Aufgaben darstellt.

Ausnahmen

ArgumentNullException

Das tasks-Argument lautete null.

ArgumentException

Das tasks-Array enthielt eine null-Aufgabe.

Beispiele

Im folgenden Beispiel werden zehn Aufgaben erstellt, von denen jede 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 Startwerten erstellt werden. Der Aufruf der WhenAll -Methode gibt dann ein Int64 Array zurück, das den Mittelwert enthält, der von jeder Aufgabe berechnet wird. Diese werden dann zur Berechnung des Gesamtmittelwerts verwendet.

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 den aufrufenden Thread nicht. Ein Aufruf der zurückgegebenen Result Eigenschaft blockiert jedoch den aufrufenden Thread.

Wenn eine der bereitgestellten Aufgaben in einem fehlerhaften Zustand abgeschlossen wird, wird die zurückgegebene Aufgabe auch in einem Faulted Zustand abgeschlossen, in dem die Ausnahmen die Aggregation der Gruppe der unverpackten Ausnahmen aus den einzelnen bereitgestellten Aufgaben enthalten.

Wenn keine der angegebenen Aufgaben 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 Aufgaben abgebrochen wurde, endet die resultierende Aufgabe im RanToCompletion Zustand. Der Result der zurückgegebenen Aufgabe wird auf ein Array festgelegt, das alle Ergebnisse der bereitgestellten Aufgaben in der gleichen Reihenfolge enthält, in der sie bereitgestellt wurden (z. B. wenn das Eingabeaufgabenarray t1, t2, t3 enthält, gibt der Ausgabetask Result ein TResult[] zurück.arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result)

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

Gilt für: