Task.WhenAll Metod

Definition

Namnområde:
System.Threading.Tasks
Sammansättningar:
mscorlib.dll, System.Threading.Tasks.dll
Sammansättning:
mscorlib.dll
Sammansättning:
System.Threading.Tasks.dll
Sammansättning:
netstandard.dll

Skapar en uppgift som ska slutföras när alla angivna uppgifter har slutförts.

Överlagringar

Name Description
WhenAll(IEnumerable<Task>)

Skapar en uppgift som slutförs när alla Task objekt i en uppräkningsbar samling har slutförts.
WhenAll(Task[])

Skapar en uppgift som ska slutföras när alla Task objekt i en matris har slutförts.
WhenAll<TResult>(IEnumerable<Task<TResult>>)

Skapar en uppgift som slutförs när alla Task<TResult> objekt i en uppräkningsbar samling har slutförts.
WhenAll<TResult>(Task<TResult>[])

Skapar en uppgift som ska slutföras när alla Task<TResult> objekt i en matris har slutförts.

WhenAll(IEnumerable<Task>)

Skapar en uppgift som slutförs när alla Task objekt i en uppräkningsbar samling har slutförts.

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

Parametrar

tasks
IEnumerable<Task>

De uppgifter som ska väntas på att slutföras.

Returer

Task

En uppgift som representerar slutförandet av alla angivna uppgifter.

Undantag

ArgumentNullException

Argumentet tasks var null.

ArgumentException

Samlingen tasks innehöll en null uppgift.

Exempel

I följande exempel skapas en uppsättning uppgifter som pingar URL:erna i en matris. Uppgifterna lagras i en List<Task> samling som skickas WhenAll(IEnumerable<Task>) till metoden. När anropet Wait till metoden ser till att alla trådar har slutförts Task.Status undersöker exemplet egenskapen för att avgöra om några uppgifter har felat.

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

Kommentarer

Överlagringarna av metoden WhenAll som returnerar ett Task objekt anropas vanligtvis när du är intresserad av status för en uppsättning aktiviteter eller i undantagen som genereras av en uppsättning aktiviteter.

Note

Anropet till WhenAll(IEnumerable<Task>) -metoden blockerar inte den anropande tråden.

Om någon av de angivna aktiviteterna slutförs i ett felaktigt tillstånd slutförs även den returnerade aktiviteten i ett tillstånd, där undantagen innehåller aggregeringen av uppsättningen oöppnade undantag från var och en Faulted av de angivna uppgifterna.

Om ingen av de angivna uppgifterna har felats, men minst en av dem avbröts, slutar den returnerade aktiviteten i Canceled tillståndet.

Om ingen av aktiviteterna har felats och ingen av aktiviteterna har avbrutits avslutas den resulterande aktiviteten i RanToCompletion tillståndet.

Om den angivna matrisen/uppräkningen inte innehåller några aktiviteter övergår den returnerade aktiviteten omedelbart till ett RanToCompletion tillstånd innan den returneras till anroparen.

Gäller för

WhenAll(Task[])

Skapar en uppgift som ska slutföras när alla Task objekt i en matris har slutförts.

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

Parametrar

tasks
Task[]

De uppgifter som ska väntas på att slutföras.

Returer

Task

En uppgift som representerar slutförandet av alla angivna uppgifter.

Undantag

ArgumentNullException

Argumentet tasks var null.

ArgumentException

Matrisen tasks innehöll en null uppgift.

Exempel

I följande exempel skapas en uppsättning uppgifter som pingar URL:erna i en matris. Uppgifterna lagras i en List<Task> samling som konverteras till en matris och skickas WhenAll(IEnumerable<Task>) till metoden. När anropet Wait till metoden ser till att alla trådar har slutförts Task.Status undersöker exemplet egenskapen för att avgöra om några uppgifter har felat.

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

Kommentarer

Överlagringarna av metoden WhenAll som returnerar ett Task objekt anropas vanligtvis när du är intresserad av status för en uppsättning aktiviteter eller i undantagen som genereras av en uppsättning aktiviteter.

Note

Anropet till WhenAll(Task[]) -metoden blockerar inte den anropande tråden.

Om någon av de angivna aktiviteterna slutförs i ett felaktigt tillstånd slutförs även den returnerade aktiviteten i ett tillstånd, där undantagen innehåller aggregeringen av uppsättningen oöppnade undantag från var och en Faulted av de angivna uppgifterna.

Om ingen av de angivna uppgifterna har felats, men minst en av dem avbröts, slutar den returnerade aktiviteten i Canceled tillståndet.

Om ingen av aktiviteterna har felats och ingen av aktiviteterna har avbrutits avslutas den resulterande aktiviteten i RanToCompletion tillståndet.

Om den angivna matrisen/uppräkningen inte innehåller några aktiviteter övergår den returnerade aktiviteten omedelbart till ett RanToCompletion tillstånd innan den returneras till anroparen.

Gäller för

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

Skapar en uppgift som slutförs när alla Task<TResult> objekt i en uppräkningsbar samling har slutförts.

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

Typparametrar

TResult

Typen av slutförd uppgift.

Parametrar

tasks
IEnumerable<Task<TResult>>

De uppgifter som ska väntas på att slutföras.

Returer

Task<TResult[]>

En uppgift som representerar slutförandet av alla angivna uppgifter.

Undantag

ArgumentNullException

Argumentet tasks var null.

ArgumentException

Samlingen tasks innehöll en null uppgift.

Exempel

I följande exempel skapas tio uppgifter som var och en instansierar en slumptalsgenerator som skapar 1 000 slumpmässiga tal mellan 1 och 1 000 och beräknar deras medelvärde. Metoden Delay(Int32) används för att fördröja instansieringen av slumptalsgeneratorerna så att de inte skapas med identiska startvärden. Anropet WhenAll till metoden returnerar sedan en Int64 matris som innehåller medelvärdet som beräknas av varje aktivitet. Dessa används sedan för att beräkna det totala medelvärdet.

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

I det här fallet lagras de tio enskilda uppgifterna i ett List<T> objekt. List<T> implementerar IEnumerable<T> gränssnittet.

Kommentarer

Anropet till WhenAll<TResult>(IEnumerable<Task<TResult>>) -metoden blockerar inte den anropande tråden. Ett anrop till den returnerade Result egenskapen blockerar dock den anropande tråden.

Om någon av de angivna aktiviteterna slutförs i ett felaktigt tillstånd slutförs även den returnerade aktiviteten i ett tillstånd, där undantagen innehåller aggregeringen av uppsättningen oöppnade undantag från var och en Faulted av de angivna uppgifterna.

Om ingen av de angivna uppgifterna har felats, men minst en av dem avbröts, slutar den returnerade aktiviteten i Canceled tillståndet.

Om ingen av aktiviteterna har felats och ingen av aktiviteterna har avbrutits avslutas den resulterande aktiviteten i RanToCompletion tillståndet. Egenskapen Task<TResult>.Result för den returnerade aktiviteten anges till en matris som innehåller alla resultat av de angivna aktiviteterna i samma ordning som de angavs (t.ex. om indataaktivitetsmatrisen innehöll t1, t2, t3 returnerar utdataaktivitetens Task<TResult>.Result egenskap en TResult[] där arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

tasks Om argumentet inte innehåller några aktiviteter övergår den returnerade aktiviteten omedelbart till ett RanToCompletion tillstånd innan den returneras till anroparen. Den returnerade TResult[] är en matris med 0 element.

Gäller för

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

Skapar en uppgift som ska slutföras när alla Task<TResult> objekt i en matris har slutförts.

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

Typparametrar

TResult

Typen av slutförd uppgift.

Parametrar

tasks
Task<TResult>[]

De uppgifter som ska väntas på att slutföras.

Returer

Task<TResult[]>

En uppgift som representerar slutförandet av alla angivna uppgifter.

Undantag

ArgumentNullException

Argumentet tasks var null.

ArgumentException

Matrisen tasks innehöll en null uppgift.

Exempel

I följande exempel skapas tio uppgifter som var och en instansierar en slumptalsgenerator som skapar 1 000 slumpmässiga tal mellan 1 och 1 000 och beräknar deras medelvärde. I det här fallet lagras de tio enskilda uppgifterna i en Task<Int64> matris. Metoden Delay(Int32) används för att fördröja instansieringen av slumptalsgeneratorerna så att de inte skapas med identiska startvärden. Anropet WhenAll till metoden returnerar sedan en Int64 matris som innehåller medelvärdet som beräknas av varje aktivitet. Dessa används sedan för att beräkna det totala medelvärdet.

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

Kommentarer

Anropet till WhenAll<TResult>(Task<TResult>[]) -metoden blockerar inte den anropande tråden. Ett anrop till den returnerade Result egenskapen blockerar dock den anropande tråden.

Om någon av de angivna aktiviteterna slutförs i ett felaktigt tillstånd slutförs även den returnerade aktiviteten i ett tillstånd, där undantagen innehåller aggregeringen av uppsättningen oöppnade undantag från var och en Faulted av de angivna uppgifterna.

Om ingen av de angivna uppgifterna har felats, men minst en av dem avbröts, slutar den returnerade aktiviteten i Canceled tillståndet.

Om ingen av aktiviteterna har felats och ingen av aktiviteterna har avbrutits avslutas den resulterande aktiviteten i RanToCompletion tillståndet. För Result den returnerade aktiviteten anges till en matris som innehåller alla resultat av de angivna aktiviteterna i samma ordning som de angavs Result (t.ex. om indataaktivitetsmatrisen innehöll t1, t2, t3 returnerar utdataaktiviteten en TResult[] där arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Om den angivna matrisen/uppräkningen inte innehåller några aktiviteter övergår den returnerade aktiviteten omedelbart till ett RanToCompletion tillstånd innan den returneras till anroparen. Den returnerade TResult[] är en matris med 0 element.

Gäller för