Task.WhenAll Method (System.Threading.Tasks) (original) (raw)
Source:
Source:
Source:
Source:
Creates a task that will complete when all of the Task 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())Type Parameters
TResult
The type of the completed task.
Parameters
Returns
A task that represents the completion of all of the supplied tasks.
Exceptions
The tasks argument was null.
The tasks collection contained a null task.
Examples
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. The Delay(Int32) method is used to delay instantiation of the random number generators so that they are not created with identical seed values. The call to the WhenAll method then returns an Int64 array that contains the mean computed by each task. 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
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 this case, the ten individual tasks are stored in a List object. List implements the IEnumerable interface.
Remarks
The call to WhenAll(IEnumerable<Task>) method does not block the calling thread. However, a call to the returned Result property does block the calling thread.
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.
If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.
If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state. The Task.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.Result property will return an TResult[] where arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).
If the tasks argument contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller. The returned TResult[] will be an array of 0 elements.