Bagikan melalui

Task.WhenAll Metode

  • Referensi

Definisi

Ruang nama:
System.Threading.Tasks
Rakitan:
System.Threading.Tasks.dll
Rakitan:
System.Runtime.dll
Rakitan:
mscorlib.dll
Rakitan:
netstandard.dll

Membuat tugas yang akan selesai ketika semua tugas yang disediakan telah selesai.

Overload

WhenAll(IEnumerable<Task>)

Membuat tugas yang akan selesai ketika semua objek Task dalam koleksi yang dapat dihitung telah selesai.
WhenAll(ReadOnlySpan<Task>)

Membuat tugas yang akan selesai ketika semua tugas yang disediakan telah selesai.
WhenAll(Task[])

Membuat tugas yang akan selesai ketika semua objek Task dalam array telah selesai.
WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)

Membuat tugas yang akan selesai ketika semua tugas yang disediakan telah selesai.
WhenAll<TResult>(IEnumerable<Task<TResult>>)

Membuat tugas yang akan selesai ketika semua objek Task<TResult> dalam koleksi yang dapat dihitung telah selesai.
WhenAll<TResult>(Task<TResult>[])

Membuat tugas yang akan selesai ketika semua objek Task<TResult> dalam array telah selesai.

WhenAll(IEnumerable<Task>)

Sumber:
Task.cs
Sumber:
Task.cs
Sumber:
Task.cs

Membuat tugas yang akan selesai ketika semua objek Task dalam koleksi yang dapat dihitung telah selesai.

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>

Tugas yang akan ditunggu untuk penyelesaian.

Mengembalikan

Task

Tugas yang mewakili penyelesaian semua tugas yang disediakan.

Pengecualian

ArgumentNullException

Argumen tasksnull.

ArgumentException

Kumpulan tasks berisi tugas null.

Contoh

Contoh berikut membuat sekumpulan tugas yang mem-ping URL dalam array. Tugas disimpan dalam koleksi List<Task> yang diteruskan ke metode WhenAll(IEnumerable<Task>). Setelah panggilan ke metode Wait memastikan bahwa semua utas telah selesai, contoh memeriksa properti Task.Status untuk menentukan apakah ada tugas yang rusak.

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

Keterangan

Kelebihan beban metode WhenAll yang mengembalikan objek Task biasanya dipanggil ketika Anda tertarik pada status sekumpulan tugas atau dalam pengecualian yang dilemparkan oleh serangkaian tugas.

Nota

Panggilan ke metode WhenAll(IEnumerable<Task>) tidak memblokir utas panggilan.

Jika salah satu tugas yang disediakan selesai dalam keadaan rusak, tugas yang dikembalikan juga akan selesai dalam status Faulted, di mana pengecualiannya akan berisi agregasi kumpulan pengecualian yang tidak dibungkus dari setiap tugas yang disediakan.

Jika tidak ada tugas yang diberikan yang rusak tetapi setidaknya salah satu dari mereka dibatalkan, tugas yang dikembalikan akan berakhir dalam status Canceled.

Jika tidak ada tugas yang rusak dan tidak ada tugas yang dibatalkan, tugas yang dihasilkan akan berakhir dalam status RanToCompletion.

Jika array yang disediakan/enumerable tidak berisi tugas, tugas yang dikembalikan akan segera beralih ke status RanToCompletion sebelum dikembalikan ke pemanggil.

Berlaku untuk

WhenAll(ReadOnlySpan<Task>)

Membuat tugas yang akan selesai ketika semua tugas yang disediakan telah selesai.

public:
 static System::Threading::Tasks::Task ^ WhenAll(ReadOnlySpan<System::Threading::Tasks::Task ^> tasks);
public static System.Threading.Tasks.Task WhenAll (scoped ReadOnlySpan<System.Threading.Tasks.Task> tasks);
static member WhenAll : ReadOnlySpan<System.Threading.Tasks.Task> -> System.Threading.Tasks.Task
Public Shared Function WhenAll (tasks As ReadOnlySpan(Of Task)) As Task

Parameter

tasks
ReadOnlySpan<Task>

Tugas yang akan ditunggu untuk penyelesaian.

Mengembalikan

Task

Tugas yang mewakili penyelesaian semua tugas yang disediakan.

Pengecualian

ArgumentException

Array tasks berisi tugas null.

Keterangan

Jika salah satu tugas yang disediakan selesai dalam keadaan rusak, tugas yang dikembalikan juga akan selesai dalam keadaan Rusak, di mana pengecualiannya akan berisi agregasi kumpulan pengecualian yang tidak dibungkus dari setiap tugas yang disediakan.

Jika tidak ada tugas yang diberikan yang rusak tetapi setidaknya salah satu dari mereka dibatalkan, tugas yang dikembalikan akan berakhir dalam status Dibatalkan.

Jika tidak ada tugas yang rusak dan tidak ada tugas yang dibatalkan, tugas yang dihasilkan akan berakhir dalam status RanToCompletion.

Jika rentang yang disediakan tidak berisi tugas, tugas yang dikembalikan akan segera beralih ke status RanToCompletion sebelum dikembalikan ke pemanggil.

Berlaku untuk

WhenAll(Task[])

Sumber:
Task.cs
Sumber:
Task.cs
Sumber:
Task.cs

Membuat tugas yang akan selesai ketika semua objek Task dalam array telah selesai.

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

Tugas yang akan ditunggu untuk penyelesaian.

Mengembalikan

Task

Tugas yang mewakili penyelesaian semua tugas yang disediakan.

Pengecualian

ArgumentNullException

Argumen tasksnull.

ArgumentException

Array tasks berisi tugas null.

Contoh

Contoh berikut membuat sekumpulan tugas yang mem-ping URL dalam array. Tugas disimpan dalam koleksi List<Task> yang dikonversi ke array dan diteruskan ke metode WhenAll(IEnumerable<Task>). Setelah panggilan ke metode Wait memastikan bahwa semua utas telah selesai, contoh memeriksa properti Task.Status untuk menentukan apakah ada tugas yang rusak.

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

Keterangan

Kelebihan beban metode WhenAll yang mengembalikan objek Task biasanya dipanggil ketika Anda tertarik pada status sekumpulan tugas atau dalam pengecualian yang dilemparkan oleh serangkaian tugas.

Nota

Panggilan ke metode WhenAll(Task[]) tidak memblokir utas panggilan.

Jika salah satu tugas yang disediakan selesai dalam keadaan rusak, tugas yang dikembalikan juga akan selesai dalam status Faulted, di mana pengecualiannya akan berisi agregasi kumpulan pengecualian yang tidak dibungkus dari setiap tugas yang disediakan.

Jika tidak ada tugas yang diberikan yang rusak tetapi setidaknya salah satu dari mereka dibatalkan, tugas yang dikembalikan akan berakhir dalam status Canceled.

Jika tidak ada tugas yang rusak dan tidak ada tugas yang dibatalkan, tugas yang dihasilkan akan berakhir dalam status RanToCompletion.

Jika array yang disediakan/enumerable tidak berisi tugas, tugas yang dikembalikan akan segera beralih ke status RanToCompletion sebelum dikembalikan ke pemanggil.

Berlaku untuk

WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)

Membuat tugas yang akan selesai ketika semua tugas yang disediakan telah selesai.

public:
generic <typename TResult>
 static System::Threading::Tasks::Task<cli::array <TResult> ^> ^ WhenAll(ReadOnlySpan<System::Threading::Tasks::Task<TResult> ^> tasks);
public static System.Threading.Tasks.Task<TResult[]> WhenAll<TResult> (scoped ReadOnlySpan<System.Threading.Tasks.Task<TResult>> tasks);
static member WhenAll : ReadOnlySpan<System.Threading.Tasks.Task<'Result>> -> System.Threading.Tasks.Task<'Result[]>
Public Shared Function WhenAll(Of TResult) (tasks As ReadOnlySpan(Of Task(Of TResult))) As Task(Of TResult())

Jenis parameter

TResult

Parameter

tasks
ReadOnlySpan<Task<TResult>>

Tugas yang akan ditunggu untuk penyelesaian.

Mengembalikan

Task<TResult[]>

Tugas yang mewakili penyelesaian semua tugas yang disediakan.

Pengecualian

ArgumentException

Array tasks berisi tugas null.

Keterangan

Jika salah satu tugas yang disediakan selesai dalam keadaan rusak, tugas yang dikembalikan juga akan selesai dalam keadaan Rusak, di mana pengecualiannya akan berisi agregasi kumpulan pengecualian yang tidak dibungkus dari setiap tugas yang disediakan.

Jika tidak ada tugas yang diberikan yang rusak tetapi setidaknya salah satu dari mereka dibatalkan, tugas yang dikembalikan akan berakhir dalam status Dibatalkan.

Jika tidak ada tugas yang rusak dan tidak ada tugas yang dibatalkan, tugas yang dihasilkan akan berakhir dalam status RanToCompletion. Hasil tugas yang dikembalikan akan diatur ke array yang berisi semua hasil tugas yang disediakan dalam urutan yang sama seperti yang disediakan (misalnya jika array tugas input berisi t1, t2, t3, Hasil tugas output akan mengembalikan TResult[] di mana arr[0] == t1. Hasil, arr[1] == t2. Hasil, dan arr[2] == t3. Hasil).

Jika array yang disediakan/enumerable tidak berisi tugas, tugas yang dikembalikan akan segera beralih ke status RanToCompletion sebelum dikembalikan ke pemanggil. TResult[] yang dikembalikan akan menjadi array dari 0 elemen.

Berlaku untuk

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

Sumber:
Task.cs
Sumber:
Task.cs
Sumber:
Task.cs

Membuat tugas yang akan selesai ketika semua objek Task<TResult> dalam koleksi yang dapat dihitung telah selesai.

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

Jenis parameter

TResult

Jenis tugas yang telah selesai.

Parameter

tasks
IEnumerable<Task<TResult>>

Tugas yang akan ditunggu untuk penyelesaian.

Mengembalikan

Task<TResult[]>

Tugas yang mewakili penyelesaian semua tugas yang disediakan.

Pengecualian

ArgumentNullException

Argumen tasksnull.

ArgumentException

Kumpulan tasks berisi tugas null.

Contoh

Contoh berikut membuat sepuluh tugas, yang masing-masing membuat generator angka acak yang membuat 1.000 angka acak antara 1 dan 1.000 dan menghitung nilai rata-ratanya. Metode Delay(Int32) digunakan untuk menunda instans generator angka acak sehingga tidak dibuat dengan nilai benih yang identik. Panggilan ke metode WhenAll kemudian mengembalikan array Int64 yang berisi rata-rata yang dihitung oleh setiap tugas. Ini kemudian digunakan untuk menghitung rata-rata keseluruhan.

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

Dalam hal ini, sepuluh tugas individual disimpan dalam objek List<T>. List<T> mengimplementasikan antarmuka IEnumerable<T>.

Keterangan

Panggilan ke metode WhenAll<TResult>(IEnumerable<Task<TResult>>) tidak memblokir utas panggilan. Namun, panggilan ke properti Result yang dikembalikan memblokir utas panggilan.

Jika salah satu tugas yang disediakan selesai dalam keadaan rusak, tugas yang dikembalikan juga akan selesai dalam status Faulted, di mana pengecualiannya akan berisi agregasi kumpulan pengecualian yang tidak dibungkus dari setiap tugas yang disediakan.

Jika tidak ada tugas yang diberikan yang rusak tetapi setidaknya salah satu dari mereka dibatalkan, tugas yang dikembalikan akan berakhir dalam status Canceled.

Jika tidak ada tugas yang rusak dan tidak ada tugas yang dibatalkan, tugas yang dihasilkan akan berakhir dalam status RanToCompletion. Properti Task<TResult>.Result tugas yang dikembalikan akan diatur ke array yang berisi semua hasil tugas yang disediakan dalam urutan yang sama seperti yang disediakan (misalnya jika array tugas input berisi t1, t2, t3, properti Task<TResult>.Result tugas output akan mengembalikan TResult[] di mana arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Jika argumen tasks tidak berisi tugas, tugas yang dikembalikan akan segera beralih ke status RanToCompletion sebelum dikembalikan ke pemanggil. TResult[] yang dikembalikan akan menjadi array dari 0 elemen.

Berlaku untuk

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

Sumber:
Task.cs
Sumber:
Task.cs
Sumber:
Task.cs

Membuat tugas yang akan selesai ketika semua objek Task<TResult> dalam array telah selesai.

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

Jenis parameter

TResult

Jenis tugas yang telah selesai.

Parameter

tasks
Task<TResult>[]

Tugas yang akan ditunggu untuk penyelesaian.

Mengembalikan

Task<TResult[]>

Tugas yang mewakili penyelesaian semua tugas yang disediakan.

Pengecualian

ArgumentNullException

Argumen tasksnull.

ArgumentException

Array tasks berisi tugas null.

Contoh

Contoh berikut membuat sepuluh tugas, yang masing-masing membuat generator angka acak yang membuat 1.000 angka acak antara 1 dan 1.000 dan menghitung nilai rata-ratanya. Dalam hal ini, sepuluh tugas individual disimpan dalam array Task<Int64>. Metode Delay(Int32) digunakan untuk menunda instans generator angka acak sehingga tidak dibuat dengan nilai benih yang identik. Panggilan ke metode WhenAll kemudian mengembalikan array Int64 yang berisi rata-rata yang dihitung oleh setiap tugas. Ini kemudian digunakan untuk menghitung rata-rata keseluruhan.

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

Keterangan

Panggilan ke metode WhenAll<TResult>(Task<TResult>[]) tidak memblokir utas panggilan. Namun, panggilan ke properti Result yang dikembalikan memblokir utas panggilan.

Jika salah satu tugas yang disediakan selesai dalam keadaan rusak, tugas yang dikembalikan juga akan selesai dalam status Faulted, di mana pengecualiannya akan berisi agregasi kumpulan pengecualian yang tidak dibungkus dari setiap tugas yang disediakan.

Jika tidak ada tugas yang diberikan yang rusak tetapi setidaknya salah satu dari mereka dibatalkan, tugas yang dikembalikan akan berakhir dalam status Canceled.

Jika tidak ada tugas yang rusak dan tidak ada tugas yang dibatalkan, tugas yang dihasilkan akan berakhir dalam status RanToCompletion. Result tugas yang dikembalikan akan diatur ke array yang berisi semua hasil tugas yang disediakan dalam urutan yang sama seperti yang disediakan (misalnya jika array tugas input berisi t1, t2, t3, tugas output Result akan mengembalikan TResult[] di mana arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

Jika array yang disediakan/enumerable tidak berisi tugas, tugas yang dikembalikan akan segera beralih ke status RanToCompletion sebelum dikembalikan ke pemanggil. TResult[] yang dikembalikan akan menjadi array dari 0 elemen.

Berlaku untuk