Task.WhenAll Methode

Definitie

Naamruimte:
System.Threading.Tasks
Assembly's:
mscorlib.dll, System.Threading.Tasks.dll
Assembly:
mscorlib.dll
Assembly:
System.Threading.Tasks.dll
Assembly:
netstandard.dll

Hiermee maakt u een taak die wordt voltooid wanneer alle opgegeven taken zijn voltooid.

Overloads

Name Description
WhenAll(IEnumerable<Task>)

Hiermee maakt u een taak die wordt voltooid wanneer alle Task objecten in een enumerable verzameling zijn voltooid.
WhenAll(Task[])

Hiermee maakt u een taak die wordt voltooid wanneer alle Task objecten in een matrix zijn voltooid.
WhenAll<TResult>(IEnumerable<Task<TResult>>)

Hiermee maakt u een taak die wordt voltooid wanneer alle Task<TResult> objecten in een enumerable verzameling zijn voltooid.
WhenAll<TResult>(Task<TResult>[])

Hiermee maakt u een taak die wordt voltooid wanneer alle Task<TResult> objecten in een matrix zijn voltooid.

WhenAll(IEnumerable<Task>)

Hiermee maakt u een taak die wordt voltooid wanneer alle Task objecten in een enumerable verzameling zijn voltooid.

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

Parameters

tasks
IEnumerable<Task>

De taken wachten op voltooiing.

Retouren

Task

Een taak die de voltooiing van alle opgegeven taken aangeeft.

Uitzonderingen

ArgumentNullException

Het tasks argument was null.

ArgumentException

De tasks verzameling bevat een null taak.

Voorbeelden

In het volgende voorbeeld wordt een set taken gemaakt die de URL's in een matrix pingen. De taken worden opgeslagen in een List<Task> verzameling die wordt doorgegeven aan de WhenAll(IEnumerable<Task>) methode. Nadat de aanroep van de Wait methode ervoor heeft gezorgd dat alle threads zijn voltooid, onderzoekt het voorbeeld de Task.Status eigenschap om te bepalen of er fouten zijn opgetreden bij taken.

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

Opmerkingen

De overbelastingen van de WhenAll methode die een Task object retourneert, worden meestal aangeroepen wanneer u geïnteresseerd bent in de status van een set taken of in de uitzonderingen die worden gegenereerd door een set taken.

Note

De aanroepmethode WhenAll(IEnumerable<Task>) blokkeert de aanroepende thread niet.

Als een van de opgegeven taken in een foutieve status wordt voltooid, wordt de geretourneerde taak ook voltooid in een Faulted status, waarbij de uitzonderingen de aggregatie van de set niet-uitgepakte uitzonderingen van elk van de opgegeven taken bevatten.

Als geen van de opgegeven taken is mislukt, maar ten minste één van deze taken is geannuleerd, eindigt de geretourneerde taak in de Canceled status.

Als geen van de taken is mislukt en geen van de taken is geannuleerd, eindigt de resulterende taak in de RanToCompletion status.

Als de opgegeven matrix/opsomming geen taken bevat, wordt de geretourneerde taak onmiddellijk overgezet naar een RanToCompletion status voordat deze wordt geretourneerd naar de aanroeper.

Van toepassing op

WhenAll(Task[])

Hiermee maakt u een taak die wordt voltooid wanneer alle Task objecten in een matrix zijn voltooid.

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

Parameters

tasks
Task[]

De taken wachten op voltooiing.

Retouren

Task

Een taak die de voltooiing van alle opgegeven taken aangeeft.

Uitzonderingen

ArgumentNullException

Het tasks argument was null.

ArgumentException

De tasks matrix bevat een null taak.

Voorbeelden

In het volgende voorbeeld wordt een set taken gemaakt die de URL's in een matrix pingen. De taken worden opgeslagen in een List<Task> verzameling die wordt geconverteerd naar een matrix en worden doorgegeven aan de WhenAll(IEnumerable<Task>) methode. Nadat de aanroep van de Wait methode ervoor heeft gezorgd dat alle threads zijn voltooid, onderzoekt het voorbeeld de Task.Status eigenschap om te bepalen of er fouten zijn opgetreden bij taken.

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

Opmerkingen

De overbelastingen van de WhenAll methode die een Task object retourneert, worden meestal aangeroepen wanneer u geïnteresseerd bent in de status van een set taken of in de uitzonderingen die worden gegenereerd door een set taken.

Note

De aanroepmethode WhenAll(Task[]) blokkeert de aanroepende thread niet.

Als een van de opgegeven taken in een foutieve status wordt voltooid, wordt de geretourneerde taak ook voltooid in een Faulted status, waarbij de uitzonderingen de aggregatie van de set niet-uitgepakte uitzonderingen van elk van de opgegeven taken bevatten.

Als geen van de opgegeven taken is mislukt, maar ten minste één van deze taken is geannuleerd, eindigt de geretourneerde taak in de Canceled status.

Als geen van de taken is mislukt en geen van de taken is geannuleerd, eindigt de resulterende taak in de RanToCompletion status.

Als de opgegeven matrix/opsomming geen taken bevat, wordt de geretourneerde taak onmiddellijk overgezet naar een RanToCompletion status voordat deze wordt geretourneerd naar de aanroeper.

Van toepassing op

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

Hiermee maakt u een taak die wordt voltooid wanneer alle Task<TResult> objecten in een enumerable verzameling zijn voltooid.

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

Het type voltooide taak.

Parameters

tasks
IEnumerable<Task<TResult>>

De taken wachten op voltooiing.

Retouren

Task<TResult[]>

Een taak die de voltooiing van alle opgegeven taken aangeeft.

Uitzonderingen

ArgumentNullException

Het tasks argument was null.

ArgumentException

De tasks verzameling bevat een null taak.

Voorbeelden

In het volgende voorbeeld worden tien taken gemaakt, die elk een generator voor willekeurige getallen maken die 1000 willekeurige getallen tussen 1 en 1.000 maakt en het gemiddelde berekent. De Delay(Int32) methode wordt gebruikt om de instantiëring van de generatoren voor willekeurige getallen te vertragen, zodat ze niet met identieke seed-waarden worden gemaakt. De aanroep van de WhenAll methode retourneert vervolgens een Int64 matrix die het gemiddelde bevat dat door elke taak wordt berekend. Deze worden vervolgens gebruikt om het totale gemiddelde te berekenen.

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 dit geval worden de tien afzonderlijke taken opgeslagen in een List<T> object. List<T> implementeert de IEnumerable<T> interface.

Opmerkingen

De aanroepmethode WhenAll<TResult>(IEnumerable<Task<TResult>>) blokkeert de aanroepende thread niet. Een aanroep naar de geretourneerde eigenschap blokkeert echter wel de aanroepende Result thread.

Als een van de opgegeven taken in een foutieve status wordt voltooid, wordt de geretourneerde taak ook voltooid in een Faulted status, waarbij de uitzonderingen de aggregatie van de set niet-uitgepakte uitzonderingen van elk van de opgegeven taken bevatten.

Als geen van de opgegeven taken is mislukt, maar ten minste één van deze taken is geannuleerd, eindigt de geretourneerde taak in de Canceled status.

Als geen van de taken is mislukt en geen van de taken is geannuleerd, eindigt de resulterende taak in de RanToCompletion status. De Task<TResult>.Result eigenschap van de geretourneerde taak wordt ingesteld op een matrix met alle resultaten van de opgegeven taken in dezelfde volgorde als de opgegeven taken (bijvoorbeeld als de invoertakenmatrix t1, t2, t3 bevat, retourneert de eigenschap van Task<TResult>.Result de uitvoertaak een TResult[] where arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Als het tasks argument geen taken bevat, wordt de geretourneerde taak onmiddellijk overgezet naar een RanToCompletion status voordat deze wordt geretourneerd naar de aanroeper. De geretourneerde TResult[] waarde is een matrix van 0 elementen.

Van toepassing op

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

Hiermee maakt u een taak die wordt voltooid wanneer alle Task<TResult> objecten in een matrix zijn voltooid.

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

Type parameters

TResult

Het type voltooide taak.

Parameters

tasks
Task<TResult>[]

De taken wachten op voltooiing.

Retouren

Task<TResult[]>

Een taak die de voltooiing van alle opgegeven taken aangeeft.

Uitzonderingen

ArgumentNullException

Het tasks argument was null.

ArgumentException

De tasks matrix bevat een null taak.

Voorbeelden

In het volgende voorbeeld worden tien taken gemaakt, die elk een generator voor willekeurige getallen maken die 1000 willekeurige getallen tussen 1 en 1.000 maakt en het gemiddelde berekent. In dit geval worden de tien afzonderlijke taken opgeslagen in een Task<Int64> matrix. De Delay(Int32) methode wordt gebruikt om de instantiëring van de generatoren voor willekeurige getallen te vertragen, zodat ze niet met identieke seed-waarden worden gemaakt. De aanroep van de WhenAll methode retourneert vervolgens een Int64 matrix die het gemiddelde bevat dat door elke taak wordt berekend. Deze worden vervolgens gebruikt om het totale gemiddelde te berekenen.

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

Opmerkingen

De aanroepmethode WhenAll<TResult>(Task<TResult>[]) blokkeert de aanroepende thread niet. Een aanroep naar de geretourneerde eigenschap blokkeert echter wel de aanroepende Result thread.

Als een van de opgegeven taken in een foutieve status wordt voltooid, wordt de geretourneerde taak ook voltooid in een Faulted status, waarbij de uitzonderingen de aggregatie van de set niet-uitgepakte uitzonderingen van elk van de opgegeven taken bevatten.

Als geen van de opgegeven taken is mislukt, maar ten minste één van deze taken is geannuleerd, eindigt de geretourneerde taak in de Canceled status.

Als geen van de taken is mislukt en geen van de taken is geannuleerd, eindigt de resulterende taak in de RanToCompletion status. De Result geretourneerde taak wordt ingesteld op een matrix met alle resultaten van de opgegeven taken in dezelfde volgorde als de opgegeven taken (bijvoorbeeld als de invoertakenmatrix t1, t2, t3 bevat, retourneert de uitvoertaak Result een TResult[] where arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Als de opgegeven matrix/opsomming geen taken bevat, wordt de geretourneerde taak onmiddellijk overgezet naar een RanToCompletion status voordat deze wordt geretourneerd naar de aanroeper. De geretourneerde TResult[] waarde is een matrix van 0 elementen.

Van toepassing op