Task.WhenAll(Of TResult) Method (Task(Of TResult)())

.NET Framework (current version)

The .NET API Reference documentation has a new home. Visit the .NET API Browser on docs.microsoft.com to see the new experience.

Creates a task that will complete when all of the Task(Of TResult) objects in an array have completed.

Namespace:   System.Threading.Tasks
Assembly:  mscorlib (in mscorlib.dll)

Public Shared Function WhenAll(Of TResult) (
	ParamArray tasks As Task(Of TResult)()
) As Task(Of TResult())


Type: System.Threading.Tasks.Task(Of TResult)()

The tasks to wait on for completion.

Return Value

Type: System.Threading.Tasks.Task(Of TResult())

A task that represents the completion of all of the supplied tasks.

Type Parameters


The type of the completed task.

Exception Condition

The tasks argument was null.


The tasks array contained a null task.

The call to WhenAll(Of TResult)(Task(Of TResult)()) 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 TaskStatus.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 TaskStatus.Canceled state.

If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the TaskStatus.RanToCompletion state. 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).

If the supplied array/enumerable contains no tasks, the returned task will immediately transition to a TaskStatus.RanToCompletion state before it's returned to the caller. The returned TResult[] will be an array of 0 elements.

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 this case, the ten individual tasks are stored in a Task<Int64> array. 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(Of TResult) method then returns an Int64 array that contains the mean computed by each task. These are then used to calculate the overall mean.

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)
                                     Return total
                                  End Function)
      Dim continuation = Task.WhenAll(tasks)
      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)
         Console.WriteLine("Mean of Means: {0:N2}, n = 10,000",
      ' Display information on faulted tasks.
         For Each t In tasks
            Console.WriteLine("Task {0}: {1}", t.Id, t.Status)
      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

Universal Windows Platform
Available since 8
.NET Framework
Available since 4.5
Portable Class Library
Supported in: portable .NET platforms
Windows Phone Silverlight
Available since 8.0
Windows Phone
Available since 8.1
Return to top