다음을 통해 공유

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

Source:
Task.cs
Source:
Task.cs
Source:
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 메서드의 오버로드는 일반적으로 작업 집합의 상태 또는 태스크 집합에 의해 throw된 예외에 관심이 있을 때 호출됩니다.

메모

WhenAll(IEnumerable<Task>) 메서드 호출은 호출 스레드를 차단하지 않습니다.

제공된 태스크 중 오류가 발생한 상태에서 완료된 작업이 Faulted 상태에서도 완료됩니다. 여기서 해당 예외에는 제공된 각 태스크에서 래핑되지 않은 예외 집합의 집계가 포함됩니다.

제공된 작업에 오류가 없지만 하나 이상의 작업이 취소된 경우 반환된 작업은 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 작업이 포함됩니다.

설명

제공된 태스크 중 오류가 발생한 상태에서 완료된 작업도 장애 상태에서 완료됩니다. 여기서 해당 예외에는 제공된 각 태스크에서 래핑되지 않은 예외 집합의 집계가 포함됩니다.

제공된 작업에 오류가 없지만 하나 이상의 작업이 취소된 경우 반환된 작업은 취소됨 상태로 종료됩니다.

오류가 발생한 작업이 없으며 취소된 작업이 없는 경우 결과 작업은 RanToCompletion 상태로 종료됩니다.

제공된 범위에 태스크가 없는 경우 반환된 작업은 호출자에게 반환되기 전에 즉시 RanToCompletion 상태로 전환됩니다.

적용 대상

WhenAll(Task[])

Source:
Task.cs
Source:
Task.cs
Source:
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 메서드의 오버로드는 일반적으로 작업 집합의 상태 또는 태스크 집합에 의해 throw된 예외에 관심이 있을 때 호출됩니다.

메모

WhenAll(Task[]) 메서드 호출은 호출 스레드를 차단하지 않습니다.

제공된 태스크 중 오류가 발생한 상태에서 완료된 작업이 Faulted 상태에서도 완료됩니다. 여기서 해당 예외에는 제공된 각 태스크에서 래핑되지 않은 예외 집합의 집계가 포함됩니다.

제공된 작업에 오류가 없지만 하나 이상의 작업이 취소된 경우 반환된 작업은 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 작업이 포함됩니다.

설명

제공된 태스크 중 오류가 발생한 상태에서 완료된 작업도 장애 상태에서 완료됩니다. 여기서 해당 예외에는 제공된 각 태스크에서 래핑되지 않은 예외 집합의 집계가 포함됩니다.

제공된 작업에 오류가 없지만 하나 이상의 작업이 취소된 경우 반환된 작업은 취소됨 상태로 종료됩니다.

오류가 발생한 작업이 없으며 취소된 작업이 없는 경우 결과 작업은 RanToCompletion 상태로 종료됩니다. 반환된 작업의 결과는 제공된 것과 동일한 순서로 제공된 작업의 모든 결과를 포함하는 배열로 설정됩니다(예: 입력 작업 배열에 t1, t2, t3이 포함된 경우 출력 태스크의 결과는 Arr[0] == t1인 TResult[]를 반환합니다. 결과, arr[1] == t2. 결과 및 arr[2] == t3입니다. 결과).

제공된 배열/열거형에 태스크가 없는 경우 반환된 작업은 호출자에게 반환되기 전에 즉시 RanToCompletion 상태로 전환됩니다. 반환된 TResult[]는 0 요소의 배열입니다.

적용 대상

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

Source:
Task.cs
Source:
Task.cs
Source:
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 작업이 포함되어 있습니다.

예제

다음 예제에서는 각각 1에서 1,000 사이의 1,000개의 난수를 만들고 해당 평균을 계산하는 난수 생성기를 인스턴스화하는 10개의 작업을 만듭니다. 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 상태에서도 완료됩니다. 여기서 해당 예외에는 제공된 각 태스크에서 래핑되지 않은 예외 집합의 집계가 포함됩니다.

제공된 작업에 오류가 없지만 하나 이상의 작업이 취소된 경우 반환된 작업은 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>[])

Source:
Task.cs
Source:
Task.cs
Source:
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 작업이 포함되어 있습니다.

예제

다음 예제에서는 각각 1에서 1,000 사이의 1,000개의 난수를 만들고 해당 평균을 계산하는 난수 생성기를 인스턴스화하는 10개의 작업을 만듭니다. 이 경우 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 상태에서도 완료됩니다. 여기서 해당 예외에는 제공된 각 태스크에서 래핑되지 않은 예외 집합의 집계가 포함됩니다.

제공된 작업에 오류가 없지만 하나 이상의 작업이 취소된 경우 반환된 작업은 Canceled 상태로 종료됩니다.

오류가 발생한 작업이 없으며 취소된 작업이 없는 경우 결과 작업은 RanToCompletion 상태로 종료됩니다. 반환된 작업의 Result 제공된 것과 동일한 순서로 제공된 작업의 모든 결과를 포함하는 배열로 설정됩니다(예: 입력 작업 배열에 t1, t2, t3이 포함된 경우 출력 태스크의 Resultarr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result)있는 TResult[] 반환합니다.

제공된 배열/열거형에 태스크가 없는 경우 반환된 작업은 호출자에게 반환되기 전에 즉시 RanToCompletion 상태로 전환됩니다. 반환된 TResult[] 0 요소의 배열이 됩니다.

적용 대상