Task.WhenAll 方法

定义

所有提供的任务已完成时,创建将完成的任务。Creates a task that will complete when all of the supplied tasks have completed.

重载

WhenAll(IEnumerable<Task>)

创建一个任务,该任务将在可枚举集合中的所有 Task 对象都已完成时完成。Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

WhenAll(Task[])

创建一个任务,该任务将在数组中的所有 Task 对象都已完成时完成。Creates a task that will complete when all of the Task objects in an array have completed.

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

创建一个任务,该任务将在可枚举集合中的所有 Task<TResult> 对象都已完成时完成。Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

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

创建一个任务,该任务将在数组中的所有 Task<TResult> 对象都已完成时完成。Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

WhenAll(IEnumerable<Task>)

创建一个任务,该任务将在可枚举集合中的所有 Task 对象都已完成时完成。Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

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>

等待完成的任务。The tasks to wait on for completion.

返回

表示所有提供的任务的完成情况的任务。A task that represents the completion of all of the supplied tasks.

异常

tasks 参数为 nullThe tasks argument was null.

tasks 收集包含 null 任务。The tasks collection contained a null task.

示例

下面的示例创建一组用于对数组中的 Url 进行 ping 操作的任务。The following example creates a set of tasks that ping the URLs in an array. 这些任务存储在传递到 WhenAll(IEnumerable<Task>) 方法的 @no__t 集合中。The tasks are stored in a List<Task> collection that is passed to the WhenAll(IEnumerable<Task>) method. 在对 Wait 方法的调用确保所有线程都完成后,该示例将检查 @no__t 属性以确定是否有任何任务出错。After the call to the Wait method ensures that all threads have completed, the example examines the Task.Status property to determine whether any tasks have faulted.

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

注解

如果对一组任务的状态或任务组引发的异常感兴趣,则通常会调用返回 @no__t 对象的 WhenAll 方法的重载。The overloads of the WhenAll method that return a Task object are typically called when you are interested in the status of a set of tasks or in the exceptions thrown by a set of tasks.

备注

WhenAll(IEnumerable<Task>) 方法的调用不会阻止调用线程。The call to WhenAll(IEnumerable<Task>) method does not block the calling thread.

如果任何提供的任务在出错状态下完成,则返回的任务也将在 Faulted 状态下完成,其中,其异常将包含每个提供的任务中已解包的异常集的聚合。If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.

如果任何提供的任务都出现故障,但至少其中一项已取消,则返回的任务将以 Canceled 状态结束。If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.

如果所有任务均出错并且任务都未被取消,则生成的任务将以 RanToCompletion 状态结束。If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state.

如果提供的数组/可枚举不包含任务,则返回的任务将在返回到调用方之前立即转换为 @no__t 状态。If the supplied array/enumerable contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller.

WhenAll(Task[])

创建一个任务,该任务将在数组中的所有 Task 对象都已完成时完成。Creates a task that will complete when all of the Task objects in an array have completed.

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

等待完成的任务。The tasks to wait on for completion.

返回

表示所有提供的任务的完成情况的任务。A task that represents the completion of all of the supplied tasks.

异常

tasks 参数为 nullThe tasks argument was null.

tasks 数组包含 null 任务。The tasks array contained a null task.

示例

下面的示例创建一组用于对数组中的 Url 进行 ping 操作的任务。The following example creates a set of tasks that ping the URLs in an array. 任务存储在转换为数组并传递给 WhenAll(IEnumerable<Task>) 方法的 @no__t 集合中。The tasks are stored in a List<Task> collection that is converted to an array and passed to the WhenAll(IEnumerable<Task>) method. 在对 Wait 方法的调用确保所有线程都完成后,该示例将检查 @no__t 属性以确定是否有任何任务出错。After the call to the Wait method ensures that all threads have completed, the example examines the Task.Status property to determine whether any tasks have faulted.

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

注解

如果对一组任务的状态或任务组引发的异常感兴趣,则通常会调用返回 @no__t 对象的 WhenAll 方法的重载。The overloads of the WhenAll method that return a Task object are typically called when you are interested in the status of a set of tasks or in the exceptions thrown by a set of tasks.

备注

WhenAll(Task[]) 方法的调用不会阻止调用线程。The call to WhenAll(Task[]) method does not block the calling thread.

如果任何提供的任务在出错状态下完成,则返回的任务也将在 Faulted 状态下完成,其中,其异常将包含每个提供的任务中已解包的异常集的聚合。If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.

如果任何提供的任务都出现故障,但至少其中一项已取消,则返回的任务将以 Canceled 状态结束。If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.

如果所有任务均出错并且任务都未被取消,则生成的任务将以 RanToCompletion 状态结束。If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state.

如果提供的数组/可枚举不包含任务,则返回的任务将在返回到调用方之前立即转换为 @no__t 状态。If the supplied array/enumerable contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller.

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

创建一个任务,该任务将在可枚举集合中的所有 Task<TResult> 对象都已完成时完成。Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

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

已完成任务的类型。The type of the completed task.

参数

tasks
IEnumerable<Task<TResult>>

等待完成的任务。The tasks to wait on for completion.

返回

Task<TResult[]>

表示所有提供的任务的完成情况的任务。A task that represents the completion of all of the supplied tasks.

异常

tasks 参数为 nullThe tasks argument was null.

tasks 集合包含 null 任务。The tasks collection contained a null task.

示例

下面的示例创建了十个任务,每个任务都实例化一个随机数生成器,该生成器可在1到1000之间创建1000随机数,并计算其平均值。The following example creates ten tasks, each of which instantiates a random number generator that creates 1,000 random numbers between 1 and 1,000 and computes their mean. @No__t-0 方法用于延迟随机数生成器的实例化,使其不是使用相同的种子值创建的。The Delay(Int32) method is used to delay instantiation of the random number generators so that they are not created with identical seed values. 调用 WhenAll 方法后,将返回一个 @no__t 为1的数组,其中包含每个任务计算的平均值。The call to the WhenAll method then returns an Int64 array that contains the mean computed by each task. 然后,将使用它们来计算整体平均值。These are then used to calculate the overall mean.

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

在这种情况下,十个单独的任务存储在 @no__t 0 对象中。In this case, the ten individual tasks are stored in a List<T> object. List<T> 实现 IEnumerable<T> 接口。List<T> implements the IEnumerable<T> interface.

注解

WhenAll<TResult>(IEnumerable<Task<TResult>>) 方法的调用不会阻止调用线程。The call to WhenAll<TResult>(IEnumerable<Task<TResult>>) method does not block the calling thread. 但是,对返回的 Result 属性的调用会阻止调用线程。However, a call to the returned Result property does block the calling thread.

如果任何提供的任务在出错状态下完成,则返回的任务也将在 Faulted 状态下完成,其中,其异常将包含每个提供的任务中已解包的异常集的聚合。If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.

如果任何提供的任务都出现故障,但至少其中一项已取消,则返回的任务将以 Canceled 状态结束。If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.

如果所有任务均出错并且任务都未被取消,则生成的任务将以 RanToCompletion 状态结束。If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state. 返回的任务的 @no__t 的属性将设置为一个数组,其中包含所提供任务的所有结果,这些结果与提供的任务的顺序相同(例如,如果输入任务数组包含 t1,t2,t3,输出任务的 Task<TResult>.Result 属性将返回 TResult[] 符合ere arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result)The Task<TResult>.Result property of the returned task will be set to an array containing all of the results of the supplied tasks in the same order as they were provided (e.g. if the input tasks array contained t1, t2, t3, the output task's Task<TResult>.Result property will return an TResult[] where arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

如果 @no__t 参数不包含任何任务,则返回的任务将在返回到调用方之前立即转换为 @no__t 状态。If the tasks argument contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller. 返回 @no__t 为0个元素的数组。The returned TResult[] will be an array of 0 elements.

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

创建一个任务,该任务将在数组中的所有 Task<TResult> 对象都已完成时完成。Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

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

已完成任务的类型。The type of the completed task.

参数

tasks
Task<TResult>[]

等待完成的任务。The tasks to wait on for completion.

返回

Task<TResult[]>

表示所有提供的任务的完成情况的任务。A task that represents the completion of all of the supplied tasks.

异常

tasks 参数为 nullThe tasks argument was null.

tasks 数组包含 null 任务。The tasks array contained a null task.

示例

下面的示例创建了十个任务,每个任务都实例化一个随机数生成器,该生成器可在1到1000之间创建1000随机数,并计算其平均值。The following example creates ten tasks, each of which instantiates a random number generator that creates 1,000 random numbers between 1 and 1,000 and computes their mean. 在这种情况下,十个单独的任务存储在一个 @no__t 的数组中。In this case, the ten individual tasks are stored in a Task<Int64> array. @No__t-0 方法用于延迟随机数生成器的实例化,使其不是使用相同的种子值创建的。The Delay(Int32) method is used to delay instantiation of the random number generators so that they are not created with identical seed values. 调用 WhenAll 方法后,将返回一个 @no__t 为1的数组,其中包含每个任务计算的平均值。The call to the WhenAll method then returns an Int64 array that contains the mean computed by each task. 然后,将使用它们来计算整体平均值。These are then used to calculate the overall mean.

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
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>[]) 方法的调用不会阻止调用线程。The call to WhenAll<TResult>(Task<TResult>[]) method does not block the calling thread. 但是,对返回的 Result 属性的调用会阻止调用线程。However, a call to the returned Result property does block the calling thread.

如果任何提供的任务在出错状态下完成,则返回的任务也将在 Faulted 状态下完成,其中,其异常将包含每个提供的任务中已解包的异常集的聚合。If any of the supplied tasks completes in a faulted state, the returned task will also complete in a Faulted state, where its exceptions will contain the aggregation of the set of unwrapped exceptions from each of the supplied tasks.

如果任何提供的任务都出现故障,但至少其中一项已取消,则返回的任务将以 Canceled 状态结束。If none of the supplied tasks faulted but at least one of them was canceled, the returned task will end in the Canceled state.

如果所有任务均出错并且任务都未被取消,则生成的任务将以 RanToCompletion 状态结束。If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state. 返回的任务的 @no__t 将设置为一个数组,其中包含所提供任务的所有结果,这些结果的顺序与提供的任务顺序相同(例如,如果输入任务数组包含 t1,t2,t3,输出任务的 Result 将返回 @no__t,其中 @no__t 为3。The Result of the returned task will be set to an array containing all of the results of the supplied tasks in the same order as they were provided (e.g. if the input tasks array contained t1, t2, t3, the output task's Result will return an TResult[] where arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).

如果提供的数组/可枚举不包含任务,则返回的任务将在返回到调用方之前立即转换为 @no__t 状态。If the supplied array/enumerable contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller. 返回 @no__t 为0个元素的数组。The returned TResult[] will be an array of 0 elements.

适用于