Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo TaskFactory.ContinueWhenAll (Task[], Action<Task[]>)

 

Data di pubblicazione: ottobre 2016

Crea un'attività di continuazione che viene avviata quando un set di attività specificate è stato completato.

Spazio dei nomi:   System.Threading.Tasks
Assembly:  mscorlib (in mscorlib.dll)

public Task ContinueWhenAll(
	Task[] tasks,
	Action<Task[]> continuationAction
)

Parametri

tasks
Type: System.Threading.Tasks.Task[]

Matrice di attività da cui continuare.

continuationAction
Type: System.Action<Task[]>

Delegato dell'azione da eseguire quando tutte le attività nella matrice tasks sono state completate.

Valore restituito

Type: System.Threading.Tasks.Task

Nuova attività di continuazione.

Exception Condition
ObjectDisposedException

Un elemento di tasks matrice è stata eliminata.

ArgumentNullException

Il tasks matrice null.

-oppure-

Il valore dell'argomento continuationAction è null.

ArgumentException

Il tasks matrice è vuota o contiene un valore null.

Il ContinueWhenAll il metodo viene eseguito il continuationAction delegato quando tutte le attività di tasks matrice completate, indipendentemente dal loro stato di completamento.

Le eccezioni generate dalle attività di tasks matrice non sono disponibili per l'attività di continuazione mediante la gestione delle eccezioni strutturata. È possibile determinare le eccezioni generate esaminando il Task.Exception proprietà di ogni attività nel tasks matrice. Da utilizzare per gestire le eccezioni generate dalle attività di gestione delle eccezioni strutturata di tasks di matrice, chiamare il Task.WaitAll(Task[]) metodo.

Nell'esempio seguente avvia attività separate che utilizzano un'espressione regolare per contare il numero di parole in un set di file di testo. Il ContinueWhenAll metodo viene utilizzato per avviare un'attività che viene visualizzato il conteggio totale delle parole quando hanno completato tutte le attività precedenti.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] filenames = { "chapter1.txt", "chapter2.txt", 
                             "chapter3.txt", "chapter4.txt",
                             "chapter5.txt" };
      string pattern = @"\b\w+\b";
      var tasks = new List<Task>();  
      int totalWords = 0;

      // Determine the number of words in each file.
      foreach (var filename in filenames) 
         tasks.Add( Task.Factory.StartNew( fn => { if (! File.Exists(fn.ToString()))
                                                      throw new FileNotFoundException("{0} does not exist.", filename);

                                                   StreamReader sr = new StreamReader(fn.ToString());
                                                   String content = sr.ReadToEnd();
                                                   sr.Close();
                                                   int words = Regex.Matches(content, pattern).Count;
                                                   Interlocked.Add(ref totalWords, words); 
                                                   Console.WriteLine("{0,-25} {1,6:N0} words", fn, words); }, 
                                           filename));

      var finalTask = Task.Factory.ContinueWhenAll(tasks.ToArray(), wordCountTasks => {
                                                    int nSuccessfulTasks = 0;
                                                    int nFailed = 0;
                                                    int nFileNotFound = 0;
                                                    foreach (var t in wordCountTasks) {
                                                       if (t.Status == TaskStatus.RanToCompletion) 
                                                          nSuccessfulTasks++;

                                                       if (t.Status == TaskStatus.Faulted) {
                                                          nFailed++;  
                                                          t.Exception.Handle( (e) => { 
                                                             if (e is FileNotFoundException)
                                                                nFileNotFound++;
                                                             return true;   
                                                          });
                                                       } 
                                                    }   
                                                    Console.WriteLine("\n{0,-25} {1,6} total words\n", 
                                                                      String.Format("{0} files", nSuccessfulTasks), 
                                                                      totalWords); 
                                                    if (nFailed > 0) {
                                                       Console.WriteLine("{0} tasks failed for the following reasons:", nFailed);
                                                       Console.WriteLine("   File not found:    {0}", nFileNotFound);
                                                       if (nFailed != nFileNotFound)
                                                          Console.WriteLine("   Other:          {0}", nFailed - nFileNotFound);
                                                    } 
                                                    });  
      finalTask.Wait();                                                                  
   }
}
// The example displays output like the following:
//       chapter2.txt               1,585 words
//       chapter1.txt               4,012 words
//       chapter5.txt               4,660 words
//       chapter3.txt               7,481 words
//       
//       4 files                    17738 total words
//       
//       1 tasks failed for the following reasons:
//          File not found:    1

La chiamata per l'attività di continuazione Task.Wait metodo non consente di gestire le eccezioni generate dalle attività precedenti, pertanto l'esempio esamina la Task.Status proprietà di ogni attività precedente per determinare se l'attività è stata completata.

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 4.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 5.0
Windows Phone Silverlight
Disponibile da 8.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: