Task.WhenAll Metodo

Definizione

Crea un'attività che verrà completata quando tutte le attività fornite saranno completate.Creates a task that will complete when all of the supplied tasks have completed.

Overload

WhenAll(IEnumerable<Task>)

Crea un'attività che verrà completata in seguito al completamento di tutti gli oggetti Task di una raccolta enumerabile.Creates a task that will complete when all of the Task objects in an enumerable collection have completed.

WhenAll(Task[])

Crea un'attività che verrà completata in seguito al completamento di tutti gli oggetti Task di una matrice.Creates a task that will complete when all of the Task objects in an array have completed.

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

Crea un'attività che verrà completata in seguito al completamento di tutti gli oggetti Task<TResult> di una raccolta enumerabile.Creates a task that will complete when all of the Task<TResult> objects in an enumerable collection have completed.

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

Crea un'attività che verrà completata in seguito al completamento di tutti gli oggetti Task<TResult> di una matrice.Creates a task that will complete when all of the Task<TResult> objects in an array have completed.

WhenAll(IEnumerable<Task>)

Crea un'attività che verrà completata in seguito al completamento di tutti gli oggetti Task di una raccolta enumerabile.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

Parametri

tasks
IEnumerable<Task>

Attività in attesa del completamento.The tasks to wait on for completion.

Restituisce

Attività che rappresenta il completamento di tutte le attività fornite.A task that represents the completion of all of the supplied tasks.

Eccezioni

Il valore dell'argomento tasks è null.The tasks argument was null.

La raccolta tasks contiene un'attività null.The tasks collection contained a null task.

Esempio

Nell'esempio seguente viene creato un set di attività che effettuano il ping degli URL in una matrice.The following example creates a set of tasks that ping the URLs in an array. Le attività vengono archiviate in una raccolta di List<Task> che viene passata al metodo WhenAll(IEnumerable<Task>).The tasks are stored in a List<Task> collection that is passed to the WhenAll(IEnumerable<Task>) method. Dopo che la chiamata al metodo Wait garantisce che tutti i thread siano stati completati, nell'esempio viene esaminata la proprietà Task.Status per determinare se si sono verificati errori nelle attività.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

Commenti

Gli overload del metodo WhenAll che restituiscono un oggetto Task vengono in genere chiamati quando si è interessati allo stato di un set di attività o nelle eccezioni generate da un set di attività.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.

Nota

La chiamata al metodo WhenAll(IEnumerable<Task>) non blocca il thread chiamante.The call to WhenAll(IEnumerable<Task>) method does not block the calling thread.

Se una delle attività fornite viene completata in uno stato di errore, anche l'attività restituita viene completata in uno stato di Faulted, in cui le eccezioni conterranno l'aggregazione del set di eccezioni senza wrapper da ognuna delle attività fornite.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.

Se nessuna delle attività fornite è stata interrotta, ma almeno una di esse è stata annullata, l'attività restituita terminerà nello stato 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.

Se nessuna delle attività è stata annullata e nessuna attività è stata annullata, l'attività risultante terminerà nello stato RanToCompletion.If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state.

Se la matrice o Enumerable fornita non contiene attività, l'attività restituita passerà immediatamente a uno stato RanToCompletion prima che venga restituito al chiamante.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[])

Crea un'attività che verrà completata in seguito al completamento di tutti gli oggetti Task di una matrice.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

Parametri

tasks
Task[]

Attività in attesa del completamento.The tasks to wait on for completion.

Restituisce

Attività che rappresenta il completamento di tutte le attività fornite.A task that represents the completion of all of the supplied tasks.

Eccezioni

Il valore dell'argomento tasks è null.The tasks argument was null.

La matrice tasks include un'attività null.The tasks array contained a null task.

Esempio

Nell'esempio seguente viene creato un set di attività che effettuano il ping degli URL in una matrice.The following example creates a set of tasks that ping the URLs in an array. Le attività vengono archiviate in una raccolta di List<Task> convertita in una matrice e passata al metodo WhenAll(IEnumerable<Task>).The tasks are stored in a List<Task> collection that is converted to an array and passed to the WhenAll(IEnumerable<Task>) method. Dopo che la chiamata al metodo Wait garantisce che tutti i thread siano stati completati, nell'esempio viene esaminata la proprietà Task.Status per determinare se si sono verificati errori nelle attività.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

Commenti

Gli overload del metodo WhenAll che restituiscono un oggetto Task vengono in genere chiamati quando si è interessati allo stato di un set di attività o nelle eccezioni generate da un set di attività.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.

Nota

La chiamata al metodo WhenAll(Task[]) non blocca il thread chiamante.The call to WhenAll(Task[]) method does not block the calling thread.

Se una delle attività fornite viene completata in uno stato di errore, anche l'attività restituita viene completata in uno stato di Faulted, in cui le eccezioni conterranno l'aggregazione del set di eccezioni senza wrapper da ognuna delle attività fornite.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.

Se nessuna delle attività fornite è stata interrotta, ma almeno una di esse è stata annullata, l'attività restituita terminerà nello stato 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.

Se nessuna delle attività è stata annullata e nessuna attività è stata annullata, l'attività risultante terminerà nello stato RanToCompletion.If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state.

Se la matrice o Enumerable fornita non contiene attività, l'attività restituita passerà immediatamente a uno stato RanToCompletion prima che venga restituito al chiamante.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>>)

Crea un'attività che verrà completata in seguito al completamento di tutti gli oggetti Task<TResult> di una raccolta enumerabile.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())

Parametri di tipo

TResult

Tipo dell'attività completata.The type of the completed task.

Parametri

tasks
IEnumerable<Task<TResult>>

Attività in attesa del completamento.The tasks to wait on for completion.

Restituisce

Task<TResult[]>

Attività che rappresenta il completamento di tutte le attività fornite.A task that represents the completion of all of the supplied tasks.

Eccezioni

Il valore dell'argomento tasks è null.The tasks argument was null.

La raccolta tasks contiene un'attività null.The tasks collection contained a null task.

Esempio

Nell'esempio seguente vengono create dieci attività, ognuna delle quali crea un'istanza di un generatore di numeri casuali che crea 1.000 numeri casuali compresi tra 1 e 1.000 e calcola la media.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. Il metodo Delay(Int32) viene usato per ritardare la creazione di istanze dei generatori di numeri casuali in modo che non vengano creati con valori di inizializzazione identici.The Delay(Int32) method is used to delay instantiation of the random number generators so that they are not created with identical seed values. La chiamata al metodo WhenAll restituisce quindi una matrice di Int64 che contiene la media calcolata da ogni attività.The call to the WhenAll method then returns an Int64 array that contains the mean computed by each task. Questi vengono quindi usati per calcolare la media complessiva.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

In questo caso, le dieci singole attività vengono archiviate in un oggetto List<T>.In this case, the ten individual tasks are stored in a List<T> object. L'oggetto List<T> implementa l'interfaccia IEnumerable<T>.List<T> implements the IEnumerable<T> interface.

Commenti

La chiamata al metodo WhenAll<TResult>(IEnumerable<Task<TResult>>) non blocca il thread chiamante.The call to WhenAll<TResult>(IEnumerable<Task<TResult>>) method does not block the calling thread. Tuttavia, una chiamata alla proprietà Result restituita blocca il thread chiamante.However, a call to the returned Result property does block the calling thread.

Se una delle attività fornite viene completata in uno stato di errore, anche l'attività restituita viene completata in uno stato di Faulted, in cui le eccezioni conterranno l'aggregazione del set di eccezioni senza wrapper da ognuna delle attività fornite.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.

Se nessuna delle attività fornite è stata interrotta, ma almeno una di esse è stata annullata, l'attività restituita terminerà nello stato 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.

Se nessuna delle attività è stata annullata e nessuna attività è stata annullata, l'attività risultante terminerà nello stato RanToCompletion.If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state. La proprietà Task<TResult>.Result dell'attività restituita verrà impostata su una matrice contenente tutti i risultati delle attività specificate nello stesso ordine in cui sono state fornite, ad esempio se la matrice delle attività di input contiene T1, T2, T3, la proprietà Task<TResult>.Result dell'attività di output restituirà un TResult[] in cui 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).

Se l'argomento tasks non contiene attività, l'attività restituita passerà immediatamente a uno stato di RanToCompletion prima che venga restituito al chiamante.If the tasks argument contains no tasks, the returned task will immediately transition to a RanToCompletion state before it's returned to the caller. Il TResult[] restituito sarà una matrice di 0 elementi.The returned TResult[] will be an array of 0 elements.

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

Crea un'attività che verrà completata in seguito al completamento di tutti gli oggetti Task<TResult> di una matrice.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())

Parametri di tipo

TResult

Tipo dell'attività completata.The type of the completed task.

Parametri

tasks
Task<TResult>[]

Attività in attesa del completamento.The tasks to wait on for completion.

Restituisce

Task<TResult[]>

Attività che rappresenta il completamento di tutte le attività fornite.A task that represents the completion of all of the supplied tasks.

Eccezioni

Il valore dell'argomento tasks è null.The tasks argument was null.

La matrice tasks include un'attività null.The tasks array contained a null task.

Esempio

Nell'esempio seguente vengono create dieci attività, ognuna delle quali crea un'istanza di un generatore di numeri casuali che crea 1.000 numeri casuali compresi tra 1 e 1.000 e calcola la media.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. In questo caso, le dieci singole attività vengono archiviate in una matrice di Task<Int64>.In this case, the ten individual tasks are stored in a Task<Int64> array. Il metodo Delay(Int32) viene usato per ritardare la creazione di istanze dei generatori di numeri casuali in modo che non vengano creati con valori di inizializzazione identici.The Delay(Int32) method is used to delay instantiation of the random number generators so that they are not created with identical seed values. La chiamata al metodo WhenAll restituisce quindi una matrice di Int64 che contiene la media calcolata da ogni attività.The call to the WhenAll method then returns an Int64 array that contains the mean computed by each task. Questi vengono quindi usati per calcolare la media complessiva.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

Commenti

La chiamata al metodo WhenAll<TResult>(Task<TResult>[]) non blocca il thread chiamante.The call to WhenAll<TResult>(Task<TResult>[]) method does not block the calling thread. Tuttavia, una chiamata alla proprietà Result restituita blocca il thread chiamante.However, a call to the returned Result property does block the calling thread.

Se una delle attività fornite viene completata in uno stato di errore, anche l'attività restituita viene completata in uno stato di Faulted, in cui le eccezioni conterranno l'aggregazione del set di eccezioni senza wrapper da ognuna delle attività fornite.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.

Se nessuna delle attività fornite è stata interrotta, ma almeno una di esse è stata annullata, l'attività restituita terminerà nello stato 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.

Se nessuna delle attività è stata annullata e nessuna attività è stata annullata, l'attività risultante terminerà nello stato RanToCompletion.If none of the tasks faulted and none of the tasks were canceled, the resulting task will end in the RanToCompletion state. Il Result dell'attività restituita verrà impostato su una matrice contenente tutti i risultati delle attività specificate nello stesso ordine in cui sono stati forniti (ad esempio, se la matrice delle attività di input contiene T1, T2, T3, l'Result dell'attività di output restituirà un TResult[] in cui arr[0] == t1.Result, arr[1] == t2.Result, and arr[2] == t3.Result).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).

Se la matrice o Enumerable fornita non contiene attività, l'attività restituita passerà immediatamente a uno stato RanToCompletion prima che venga restituito al chiamante.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. Il TResult[] restituito sarà una matrice di 0 elementi.The returned TResult[] will be an array of 0 elements.

Si applica a