次の方法で共有

Task.WhenAll メソッド

  • リファレンス

定義

名前空間:
System.Threading.Tasks
アセンブリ:
System.Threading.Tasks.dll
アセンブリ:
System.Runtime.dll
アセンブリ:
mscorlib.dll
アセンブリ:
netstandard.dll

指定されたすべてのタスクが完了したときに完了するタスクを作成します。

オーバーロード

WhenAll(IEnumerable<Task>)

列挙可能なコレクション内のすべての Task オブジェクトが完了したときに完了するタスクを作成します。
WhenAll(ReadOnlySpan<Task>)

指定されたすべてのタスクが完了したときに完了するタスクを作成します。
WhenAll(Task[])

配列内のすべての Task オブジェクトが完了したときに完了するタスクを作成します。
WhenAll<TResult>(ReadOnlySpan<Task<TResult>>)

指定されたすべてのタスクが完了したときに完了するタスクを作成します。
WhenAll<TResult>(IEnumerable<Task<TResult>>)

列挙可能なコレクション内のすべての Task<TResult> オブジェクトが完了したときに完了するタスクを作成します。
WhenAll<TResult>(Task<TResult>[])

配列内のすべての Task<TResult> オブジェクトが完了したときに完了するタスクを作成します。

WhenAll(IEnumerable<Task>)

ソース:
Task.cs
ソース:
Task.cs
ソース:
Task.cs

列挙可能なコレクション内のすべての Task オブジェクトが完了したときに完了するタスクを作成します。

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

パラメーター

tasks
IEnumerable<Task>

完了を待機するタスク。

戻り値

Task

指定されたすべてのタスクの完了を表すタスク。

例外

ArgumentNullException

tasks 引数が nullされました。

ArgumentException

tasks コレクションには、null タスクが含まれていました。

例

次の例では、配列内の URL に ping を実行する一連のタスクを作成します。 タスクは、WhenAll(IEnumerable<Task>) メソッドに渡される List<Task> コレクションに格納されます。 Wait メソッドの呼び出しによってすべてのスレッドが完了したことを確認した後、Task.Status プロパティを調べて、タスクに障害が発生したかどうかを判断します。

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

注釈

Task オブジェクトを返す WhenAll メソッドのオーバーロードは、通常、一連のタスクの状態や、一連のタスクによってスローされる例外に関心がある場合に呼び出されます。

手記

WhenAll(IEnumerable<Task>) メソッドを呼び出しても、呼び出し元のスレッドはブロックされません。

指定されたタスクのいずれかがエラー状態で完了した場合、返されたタスクも Faulted 状態で完了します。その場合、その例外には、指定された各タスクからのラップされていない例外のセットの集計が含まれます。

指定されたタスクのいずれもエラーが発生しなかったが、そのうちの少なくとも 1 つが取り消された場合、返されたタスクは Canceled 状態で終了します。

エラーが発生したタスクもタスクも取り消されなかった場合、結果のタスクは RanToCompletion 状態で終了します。

指定された配列/列挙型にタスクが含まれている場合、返されたタスクは、呼び出し元に返される前に、すぐに RanToCompletion 状態に遷移します。

適用対象

WhenAll(ReadOnlySpan<Task>)

指定されたすべてのタスクが完了したときに完了するタスクを作成します。

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

パラメーター

tasks
ReadOnlySpan<Task>

完了を待機するタスク。

戻り値

Task

指定されたすべてのタスクの完了を表すタスク。

例外

ArgumentException

tasks 配列には、null タスクが含まれています。

注釈

指定されたタスクのいずれかがエラー状態で完了した場合、返されたタスクも Faulted 状態で完了します。その例外には、指定された各タスクのラップされていない例外のセットの集計が含まれます。

指定されたタスクのいずれもエラーが発生しなかったが、少なくとも 1 つが取り消された場合、返されたタスクは取り消された状態で終了します。

エラーが発生したタスクが 1 つも実行されておらず、どのタスクも取り消されなかった場合、結果のタスクは RanToCompletion 状態で終了します。

指定されたスパンにタスクが含まれている場合、返されたタスクは、呼び出し元に返される前に、すぐに RanToCompletion 状態に遷移します。

適用対象

WhenAll(Task[])

ソース:
Task.cs
ソース:
Task.cs
ソース:
Task.cs

配列内のすべての Task オブジェクトが完了したときに完了するタスクを作成します。

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

パラメーター

tasks
Task[]

完了を待機するタスク。

戻り値

Task

指定されたすべてのタスクの完了を表すタスク。

例外

ArgumentNullException

tasks 引数が nullされました。

ArgumentException

tasks 配列には、null タスクが含まれていました。

例

次の例では、配列内の URL に ping を実行する一連のタスクを作成します。 タスクは、配列に変換され、WhenAll(IEnumerable<Task>) メソッドに渡される List<Task> コレクションに格納されます。 Wait メソッドの呼び出しによってすべてのスレッドが完了したことを確認した後、Task.Status プロパティを調べて、タスクに障害が発生したかどうかを判断します。

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

注釈

Task オブジェクトを返す WhenAll メソッドのオーバーロードは、通常、一連のタスクの状態や、一連のタスクによってスローされる例外に関心がある場合に呼び出されます。

手記

WhenAll(Task[]) メソッドを呼び出しても、呼び出し元のスレッドはブロックされません。

指定されたタスクのいずれかがエラー状態で完了した場合、返されたタスクも Faulted 状態で完了します。その場合、その例外には、指定された各タスクからのラップされていない例外のセットの集計が含まれます。

指定されたタスクのいずれもエラーが発生しなかったが、そのうちの少なくとも 1 つが取り消された場合、返されたタスクは Canceled 状態で終了します。

エラーが発生したタスクもタスクも取り消されなかった場合、結果のタスクは RanToCompletion 状態で終了します。

指定された配列/列挙型にタスクが含まれている場合、返されたタスクは、呼び出し元に返される前に、すぐに RanToCompletion 状態に遷移します。

適用対象

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

指定されたすべてのタスクが完了したときに完了するタスクを作成します。

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

型パラメーター

TResult

パラメーター

tasks
ReadOnlySpan<Task<TResult>>

完了を待機するタスク。

戻り値

Task<TResult[]>

指定されたすべてのタスクの完了を表すタスク。

例外

ArgumentException

tasks 配列には、null タスクが含まれています。

注釈

指定されたタスクのいずれかがエラー状態で完了した場合、返されたタスクも Faulted 状態で完了します。その例外には、指定された各タスクのラップされていない例外のセットの集計が含まれます。

指定されたタスクのいずれもエラーが発生しなかったが、少なくとも 1 つが取り消された場合、返されたタスクは取り消された状態で終了します。

エラーが発生したタスクが 1 つも実行されておらず、どのタスクも取り消されなかった場合、結果のタスクは RanToCompletion 状態で終了します。 返されたタスクの結果は、指定されたタスクのすべての結果が指定された順序で格納されている配列に設定されます (たとえば、入力タスクの配列に t1、t2、t3 が含まれている場合、出力タスクの結果は TResult[] where arr[0] == t1 を返します。結果、arr[1] == t2。結果、arr[2] == t3。結果)。

指定された配列/列挙型にタスクが含まれている場合、返されたタスクは、呼び出し元に返される前に、すぐに RanToCompletion 状態に遷移します。 返される TResult[] は、0 個の要素の配列になります。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
Task.cs

列挙可能なコレクション内のすべての Task<TResult> オブジェクトが完了したときに完了するタスクを作成します。

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

型パラメーター

TResult

完了したタスクの種類。

パラメーター

tasks
IEnumerable<Task<TResult>>

完了を待機するタスク。

戻り値

Task<TResult[]>

指定されたすべてのタスクの完了を表すタスク。

例外

ArgumentNullException

tasks 引数が nullされました。

ArgumentException

tasks コレクションには、null タスクが含まれていました。

例

次の例では、10 個のタスクを作成し、それぞれが 1 ~ 1,000 の間に 1,000 個の乱数を作成し、その平均値を計算する乱数ジェネレーターをインスタンス化します。 Delay(Int32) メソッドは、乱数ジェネレーターのインスタンス化を遅延して、同じシード値で作成されないようにするために使用されます。 WhenAll メソッドの呼び出しは、各タスクによって計算された平均を含む Int64 配列を返します。 これらは、全体の平均を計算するために使用されます。

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

この場合、10 個の個々のタスクが List<T> オブジェクトに格納されます。 List<T> は、IEnumerable<T> インターフェイスを実装します。

注釈

WhenAll<TResult>(IEnumerable<Task<TResult>>) メソッドを呼び出しても、呼び出し元のスレッドはブロックされません。 ただし、返された Result プロパティを呼び出すと、呼び出し元のスレッドがブロックされます。

指定されたタスクのいずれかがエラー状態で完了した場合、返されたタスクも Faulted 状態で完了します。その場合、その例外には、指定された各タスクからのラップされていない例外のセットの集計が含まれます。

指定されたタスクのいずれもエラーが発生しなかったが、そのうちの少なくとも 1 つが取り消された場合、返されたタスクは Canceled 状態で終了します。

エラーが発生したタスクもタスクも取り消されなかった場合、結果のタスクは RanToCompletion 状態で終了します。 返されたタスクの Task<TResult>.Result プロパティは、指定されたタスクの結果をすべて含む配列に設定されます (たとえば、入力タスクの配列に t1、t2、t3 が含まれている場合、出力タスクの Task<TResult>.Result プロパティは、arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result)TResult[] を返します。

tasks 引数にタスクが含まれている場合、返されたタスクは、呼び出し元に返される前に、すぐに RanToCompletion 状態に遷移します。 返される TResult[] は、0 個の要素の配列になります。

適用対象

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

ソース:
Task.cs
ソース:
Task.cs
ソース:
Task.cs

配列内のすべての Task<TResult> オブジェクトが完了したときに完了するタスクを作成します。

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

型パラメーター

TResult

完了したタスクの種類。

パラメーター

tasks
Task<TResult>[]

完了を待機するタスク。

戻り値

Task<TResult[]>

指定されたすべてのタスクの完了を表すタスク。

例外

ArgumentNullException

tasks 引数が nullされました。

ArgumentException

tasks 配列には、null タスクが含まれていました。

例

次の例では、10 個のタスクを作成し、それぞれが 1 ~ 1,000 の間に 1,000 個の乱数を作成し、その平均値を計算する乱数ジェネレーターをインスタンス化します。 この場合、10 個の個々のタスクが Task<Int64> 配列に格納されます。 Delay(Int32) メソッドは、乱数ジェネレーターのインスタンス化を遅延して、同じシード値で作成されないようにするために使用されます。 WhenAll メソッドの呼び出しは、各タスクによって計算された平均を含む Int64 配列を返します。 これらは、全体の平均を計算するために使用されます。

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

注釈

WhenAll<TResult>(Task<TResult>[]) メソッドを呼び出しても、呼び出し元のスレッドはブロックされません。 ただし、返された Result プロパティを呼び出すと、呼び出し元のスレッドがブロックされます。

指定されたタスクのいずれかがエラー状態で完了した場合、返されたタスクも Faulted 状態で完了します。その場合、その例外には、指定された各タスクからのラップされていない例外のセットの集計が含まれます。

指定されたタスクのいずれもエラーが発生しなかったが、そのうちの少なくとも 1 つが取り消された場合、返されたタスクは Canceled 状態で終了します。

エラーが発生したタスクもタスクも取り消されなかった場合、結果のタスクは RanToCompletion 状態で終了します。 返されたタスクの Result は、指定されたタスクの結果をすべて含む配列に設定されます (たとえば、入力タスク配列に t1、t2、t3 が含まれている場合、出力タスクの Result は arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result)TResult[] を返します。

指定された配列/列挙型にタスクが含まれている場合、返されたタスクは、呼び出し元に返される前に、すぐに RanToCompletion 状態に遷移します。 返される TResult[] は、0 個の要素の配列になります。

適用対象