Task.WhenAll Task.WhenAll Task.WhenAll Task.WhenAll Method

Definition

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle angegebenen Aufgaben abgeschlossen sind.Creates a task that will complete when all of the supplied tasks have completed.

Überlädt

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

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einer aufzählbaren Sammlung abgeschlossen sind.Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[])

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einem Array abgeschlossen sind.Creates a task that will complete when all of the Task objects in an array have completed.

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

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult>-Objekte in einer aufzählbaren Sammlung abgeschlossen sind.Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

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

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult>-Objekte in einem Array abgeschlossen sind.Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

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

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einer aufzählbaren Sammlung abgeschlossen sind.Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

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.The tasks to wait on for completion.

Gibt zurück

Eine Aufgabe, die den Abschluss aller angegebenen Aufgaben darstellt.A task that represents the completion of all of the supplied tasks.

Ausnahmen

Das tasks-Argument lautete null.The tasks argument was null.

Die tasks-Auflistung enthielt eine null-Aufgabe.The tasks collection contained a null task.

Beispiele

Das folgende Beispiel erstellt eine Reihe von Aufgaben, die die URLs in einem Array zu pingen.The following example creates a set of tasks that ping the URLs in an array. Die Aufgaben werden gespeichert, einem List<Task> -Auflistung, die an die WhenAll(IEnumerable<Task>) Methode.The tasks are stored in a List<Task> collection that is passed to the WhenAll(IEnumerable<Task>) method. Nach dem Aufruf der Wait Methode stellt sicher, dass alle Threads abgeschlossen haben, im Beispiel wird untersucht die Task.Status Eigenschaft, um zu bestimmen, ob alle Tasks einen Fehler verursacht haben.After the call to the Wait method ensures that all threads have completed, the example examines the Task.Status property to determine whether any tasks have faulted.

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

Überladungen der der WhenAll Methode, die Zurückgeben einer Task Objekt werden in der Regel aufgerufen, wenn Sie möchten, in den Status einer Reihe von Aufgaben oder in der durch eine Reihe von Aufgaben ausgelösten Ausnahmen sind.The overloads of the WhenAll method that return a Task object are typically called when you are interested in the status of a set of tasks or in the exceptions thrown by a set of tasks.

Hinweis

Der Aufruf von WhenAll(IEnumerable<Task>) Methode wird den aufrufenden Thread nicht blockiert.The call to WhenAll(IEnumerable<Task>) method does not block the calling thread.

Wenn die angegebenen Aufgaben abgeschlossen ist, in einem fehlerhaften Zustand, wird die zurückgegebene Aufgabe auch abgeschlossen ein Faulted Status, die Ausnahmen, in dem die Aggregation des Satzes von entwrappte Ausnahmen aller angegebenen Aufgaben enthält.If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.

Wenn keiner der angegebenen Aufgaben einen Fehler verursacht, aber mindestens eine von ihnen abgebrochen wurde, endet die zurückgegebene Aufgabe in der Canceled Zustand.If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.

Wenn keiner der Vorgänge einen Fehler verursacht, und keinen der Tasks abgebrochen wurden, endet die resultierende Aufgabe in der RanToCompletion Zustand.If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state.

Wenn das angegebene Array/aufzählbare Element keine Aufgaben enthält, die zurückgegebene Aufgabe geht sofort in eine RanToCompletion Status, bevor es an den Aufrufer zurückgegeben wird.If the supplied array/enumerable contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller.

WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[]) WhenAll(Task[])

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task-Objekte in einem Array abgeschlossen sind.Creates a task that will complete when all of the Task objects in an array have completed.

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.The tasks to wait on for completion.

Gibt zurück

Eine Aufgabe, die den Abschluss aller angegebenen Aufgaben darstellt.A task that represents the completion of all of the supplied tasks.

Ausnahmen

Das tasks-Argument lautete null.The tasks argument was null.

Das tasks-Array enthielt eine null-Aufgabe.The tasks array contained a null task.

Beispiele

Das folgende Beispiel erstellt eine Reihe von Aufgaben, die die URLs in einem Array zu pingen.The following example creates a set of tasks that ping the URLs in an array. Die Aufgaben werden gespeichert, einem List<Task> -Auflistung, die in ein Bytearray konvertierten und übergeben die WhenAll(IEnumerable<Task>) Methode.The tasks are stored in a List<Task> collection that is converted to an array and passed to the WhenAll(IEnumerable<Task>) method. Nach dem Aufruf der Wait Methode stellt sicher, dass alle Threads abgeschlossen haben, im Beispiel wird untersucht die Task.Status Eigenschaft, um zu bestimmen, ob alle Tasks einen Fehler verursacht haben.After the call to the Wait method ensures that all threads have completed, the example examines the Task.Status property to determine whether any tasks have faulted.

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

Überladungen der der WhenAll Methode, die Zurückgeben einer Task Objekt werden in der Regel aufgerufen, wenn Sie möchten, in den Status einer Reihe von Aufgaben oder in der durch eine Reihe von Aufgaben ausgelösten Ausnahmen sind.The overloads of the WhenAll method that return a Task object are typically called when you are interested in the status of a set of tasks or in the exceptions thrown by a set of tasks.

Hinweis

Der Aufruf von WhenAll(Task[]) Methode wird den aufrufenden Thread nicht blockiert.The call to WhenAll(Task[]) method does not block the calling thread.

Wenn die angegebenen Aufgaben abgeschlossen ist, in einem fehlerhaften Zustand, wird die zurückgegebene Aufgabe auch abgeschlossen ein Faulted Status, die Ausnahmen, in dem die Aggregation des Satzes von entwrappte Ausnahmen aller angegebenen Aufgaben enthält.If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.

Wenn keiner der angegebenen Aufgaben einen Fehler verursacht, aber mindestens eine von ihnen abgebrochen wurde, endet die zurückgegebene Aufgabe in der Canceled Zustand.If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.

Wenn keiner der Vorgänge einen Fehler verursacht, und keinen der Tasks abgebrochen wurden, endet die resultierende Aufgabe in der RanToCompletion Zustand.If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state.

Wenn das angegebene Array/aufzählbare Element keine Aufgaben enthält, die zurückgegebene Aufgabe geht sofort in eine RanToCompletion Status, bevor es an den Aufrufer zurückgegeben wird.If the supplied array/enumerable contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller.

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

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult>-Objekte in einer aufzählbaren Sammlung abgeschlossen sind.Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

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.The type of the completed task.

Parameter

tasks
IEnumerable<Task<TResult>>

Die Aufgaben, auf deren Abschluss gewartet werden soll.The tasks to wait on for completion.

Gibt zurück

Task<TResult[]>

Eine Aufgabe, die den Abschluss aller angegebenen Aufgaben darstellt.A task that represents the completion of all of the supplied tasks.

Ausnahmen

Das tasks-Argument lautete null.The tasks argument was null.

Die tasks-Auflistung enthielt eine null-Aufgabe.The tasks collection contained a null task.

Beispiele

Das folgende Beispiel erstellt, zehn Aufgaben, von die jede einen Zufallszahlengenerator instanziiert, der 1.000 zufällige Zahlen zwischen 1 und 1.000 erstellt und ihrem Mittelwert berechnet wird.The following example creates ten tasks, each of which instantiates a random number generator that creates 1,000 random numbers between 1 and 1,000 and computes their mean. Die Delay(Int32) Methode wird verwendet, um die Instanziierung von random Number-Generatoren zu verzögern, damit sie nicht mit dem identischen Startwerten erstellt werden.The Delay(Int32) method is used to delay instantiation of the random number generators so that they are not created with identical seed values. Der Aufruf der WhenAll Methodenrückgabe klicken Sie dann eine Int64 Array mit den Mittelwert berechnet wird, durch die einzelnen Tasks.The call to the WhenAll method then returns an Int64 array that contains the mean computed by each task. Diese werden dann verwendet, dem gesamtmittelwert zu berechnen.These are then used to calculate the overall mean.

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
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 einzelnen zehn Tasks gespeichert, einem List<T> Objekt.In this case, the ten individual tasks are stored in a List<T> object. List<T> implementiert die IEnumerable<T>-Schnittstelle.List<T> implements the IEnumerable<T> interface.

Hinweise

Der Aufruf von WhenAll<TResult>(IEnumerable<Task<TResult>>) Methode wird den aufrufenden Thread nicht blockiert.The call to WhenAll<TResult>(IEnumerable<Task<TResult>>) method does not block the calling thread. Allerdings einen Aufruf zurückgegebenen Result Eigenschaft wird den aufrufenden Thread blockiert.However, a call to the returned Result property does block the calling thread.

Wenn die angegebenen Aufgaben abgeschlossen ist, in einem fehlerhaften Zustand, wird die zurückgegebene Aufgabe auch abgeschlossen ein Faulted Status, die Ausnahmen, in dem die Aggregation des Satzes von entwrappte Ausnahmen aller angegebenen Aufgaben enthält.If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.

Wenn keiner der angegebenen Aufgaben einen Fehler verursacht, aber mindestens eine von ihnen abgebrochen wurde, endet die zurückgegebene Aufgabe in der Canceled Zustand.If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.

Wenn keiner der Vorgänge einen Fehler verursacht, und keinen der Tasks abgebrochen wurden, endet die resultierende Aufgabe in der RanToCompletion Zustand.If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state. Die Task<TResult>.Result Eigenschaft der zurückgegebenen Aufgabe wird festgelegt werden, auf ein Array mit alle Ergebnisse der angegebenen Aufgaben in der gleichen Reihenfolge, da sie bereitgestellt wurden (z. B. wenn die Eingabe enthaltene Array t1, t2, t3, die Ausgabe des Tasks Aufgaben Task<TResult>.Result Eigenschaft zurück ein TResult[] , in denen arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).The Task<TResult>.Result property of the returned task will be set to an array containing all of the results of the supplied tasks in the same order as they were provided (e.g. if the input tasks array contained t1, t2, t3, the output task's Task<TResult>.Result property will return an TResult[] where arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Wenn die tasks Argument enthält keine Vorgänge, die zurückgegebene Aufgabe geht sofort in eine RanToCompletion Status, bevor es an den Aufrufer zurückgegeben wird.If the tasks argument contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller. Das zurückgegebene TResult[] werden ein Array mit 0 Elementen.The returned TResult[] will be an array of 0 elements.

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

Erstellt eine Aufgabe, die abgeschlossen wird, wenn alle Task<TResult>-Objekte in einem Array abgeschlossen sind.Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

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.The type of the completed task.

Parameter

tasks
Task<TResult>[]

Die Aufgaben, auf deren Abschluss gewartet werden soll.The tasks to wait on for completion.

Gibt zurück

Task<TResult[]>

Eine Aufgabe, die den Abschluss aller angegebenen Aufgaben darstellt.A task that represents the completion of all of the supplied tasks.

Ausnahmen

Das tasks-Argument lautete null.The tasks argument was null.

Das tasks-Array enthielt eine null-Aufgabe.The tasks array contained a null task.

Beispiele

Das folgende Beispiel erstellt, zehn Aufgaben, von die jede einen Zufallszahlengenerator instanziiert, der 1.000 zufällige Zahlen zwischen 1 und 1.000 erstellt und ihrem Mittelwert berechnet wird.The following example creates ten tasks, each of which instantiates a random number generator that creates 1,000 random numbers between 1 and 1,000 and computes their mean. In diesem Fall werden die einzelnen zehn Tasks gespeichert, einem Task<Int64> Array.In this case, the ten individual tasks are stored in a Task<Int64> array. Die Delay(Int32) Methode wird verwendet, um die Instanziierung von random Number-Generatoren zu verzögern, damit sie nicht mit dem identischen Startwerten erstellt werden.The Delay(Int32) method is used to delay instantiation of the random number generators so that they are not created with identical seed values. Der Aufruf der WhenAll Methodenrückgabe klicken Sie dann eine Int64 Array mit den Mittelwert berechnet wird, durch die einzelnen Tasks.The call to the WhenAll method then returns an Int64 array that contains the mean computed by each task. Diese werden dann verwendet, dem gesamtmittelwert zu berechnen.These are then used to calculate the overall mean.

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
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 von WhenAll<TResult>(Task<TResult>[]) Methode wird den aufrufenden Thread nicht blockiert.The call to WhenAll<TResult>(Task<TResult>[]) method does not block the calling thread. Allerdings einen Aufruf zurückgegebenen Result Eigenschaft wird den aufrufenden Thread blockiert.However, a call to the returned Result property does block the calling thread.

Wenn die angegebenen Aufgaben abgeschlossen ist, in einem fehlerhaften Zustand, wird die zurückgegebene Aufgabe auch abgeschlossen ein Faulted Status, die Ausnahmen, in dem die Aggregation des Satzes von entwrappte Ausnahmen aller angegebenen Aufgaben enthält.If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.

Wenn keiner der angegebenen Aufgaben einen Fehler verursacht, aber mindestens eine von ihnen abgebrochen wurde, endet die zurückgegebene Aufgabe in der Canceled Zustand.If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.

Wenn keiner der Vorgänge einen Fehler verursacht, und keinen der Tasks abgebrochen wurden, endet die resultierende Aufgabe in der RanToCompletion Zustand.If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state. Die Result der zurückgegebenen Aufgabe wird festgelegt auf ein Array mit alle Ergebnisse der angegebenen Aufgaben in der gleichen Reihenfolge, da sie bereitgestellt wurden (z. B. wenn die Eingabe enthaltene Array t1, t2, t3, die Ausgabe des Tasks Aufgaben Result gibt ein TResult[] wo arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).The Result of the returned task will be set to an array containing all of the results of the supplied tasks in the same order as they were provided (e.g. if the input tasks array contained t1, t2, t3, the output task's Result will return an TResult[] where arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Wenn das angegebene Array/aufzählbare Element keine Aufgaben enthält, die zurückgegebene Aufgabe geht sofort in eine RanToCompletion Status, bevor es an den Aufrufer zurückgegeben wird.If the supplied array/enumerable contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller. Das zurückgegebene TResult[] werden ein Array mit 0 Elementen.The returned TResult[] will be an array of 0 elements.

Gilt für: