TaskFactory.ContinueWhenAll Método

Referencia

Definición

Espacio de nombres:: System.Threading.Tasks

Ensamblado:: System.Threading.Tasks.dll

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

Sobrecargas

ContinueWhenAll(Task[], Action<Task[]>)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll(Task[], Action<Task[]>, CancellationToken)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll(Task[], Action<Task[]>, TaskContinuationOptions)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll(Task[], Action<Task[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, TaskContinuationOptions)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, TaskContinuationOptions)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, TaskContinuationOptions)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.
ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

ContinueWhenAll(Task[], Action<Task[]>)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
 System::Threading::Tasks::Task ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Action<cli::array <System::Threading::Tasks::Task ^> ^> ^ continuationAction);

public System.Threading.Tasks.Task ContinueWhenAll (System.Threading.Tasks.Task[] tasks, Action<System.Threading.Tasks.Task[]> continuationAction);

member this.ContinueWhenAll : System.Threading.Tasks.Task[] * Action<System.Threading.Tasks.Task[]> -> System.Threading.Tasks.Task

Public Function ContinueWhenAll (tasks As Task(), continuationAction As Action(Of Task())) As Task

Parámetros

tasks: Task[]

Matriz de tareas desde la que se va a continuar.

continuationAction: Action<Task[]>

Delegado de acción que se va a ejecutar cuando se completen todas las tareas de la matriz tasks.

Devoluciones

Task

Nueva tarea de continuación.

Excepciones

ObjectDisposedException

Un elemento de la matriz tasks se ha desechado.

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationAction es null.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

Ejemplos

En el ejemplo siguiente se inician tareas independientes que usan una expresión regular para contar el número de palabras de un conjunto de archivos de texto. El ContinueWhenAll método se usa para iniciar una tarea que muestra el recuento total de palabras cuando se han completado todas las tareas anteriores.

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

Imports System.Collections.Generic
Imports System.IO
Imports System.Threading
Imports System.Threading.Tasks
Imports System.Text.RegularExpressions

Module Example
   Dim totalWords As Integer = 0
   
   Public Sub Main()
      Dim filenames() As String = { "chapter1.txt", "chapter2.txt", 
                                    "chapter3.txt", "chapter4.txt",
                                    "chapter5.txt" }
      Dim pattern As String = "\b\w+\b"
      Dim tasks As New List(Of Task)()  
        
      ' Determine the number of words in each file.
      For Each filename In filenames 
         tasks.Add(Task.Factory.StartNew( Sub(fn)
                                             If Not File.Exists(filename)
                                                Throw New FileNotFoundException("{0} does not exist.", filename)
                                             End If
                                             
                                             Dim sr As New StreamReader(fn.ToString())
                                             Dim content As String = sr.ReadToEnd()
                                             sr.Close()
                                             Dim words As Integer = Regex.Matches(content, pattern).Count
                                             Interlocked.Add(totalWords, words) 
                                             Console.WriteLine("{0,-25} {1,6:N0} words", fn, words)
                                          End Sub, filename))
      Next
      
      Dim finalTask As Task = Task.Factory.ContinueWhenAll(tasks.ToArray(), 
                                                           Sub(wordCountTasks As Task() )
                                                              Dim nSuccessfulTasks As Integer = 0
                                                              Dim nFailed As Integer = 0
                                                              Dim nFileNotFound As Integer = 0
                                                              For Each t In wordCountTasks
                                                                 If t.Status = TaskStatus.RanToCompletion Then _ 
                                                                    nSuccessfulTasks += 1
                                                       
                                                                 If t.Status = TaskStatus.Faulted Then
                                                                    nFailed += 1  
                                                                    t.Exception.Handle(Function(e As Exception) 
                                                                                          If TypeOf e Is FileNotFoundException Then
                                                                                             nFileNotFound += 1
                                                                                          End If   
                                                                                          Return True   
                                                                                       End Function)                       
                                                                 End If 
                                                              Next   
                                                              Console.WriteLine()
                                                              Console.WriteLine("{0,-25} {1,6} total words", 
                                                                                String.Format("{0} files", nSuccessfulTasks), 
                                                                                totalWords) 
                                                              If nFailed > 0 Then
                                                                 Console.WriteLine()
                                                                 Console.WriteLine("{0} tasks failed for the following reasons:", nFailed)
                                                                 Console.WriteLine("   File not found:    {0}", nFileNotFound)
                                                                 If nFailed <> nFileNotFound Then
                                                                    Console.WriteLine("   Other:          {0}", nFailed - nFileNotFound)
                                                                 End If 
                                                              End If
                                                           End Sub)
      finalTask.Wait()                                                                  
   End Sub
   
   Private Sub DisplayResult(wordCountTasks As Task())
   End Sub
End Module
' 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 llamada al método de la tarea de Task.Wait continuación no permite controlar las excepciones producidas por las tareas anteriores, por lo que el ejemplo examina la Task.Status propiedad de cada tarea antecedente para determinar si la tarea se realizó correctamente.

Comentarios

El ContinueWhenAll método ejecuta el continuationAction delegado cuando se han completado todas las tareas de la tasks matriz, independientemente de su estado de finalización.

Las excepciones producidas por las tareas de la tasks matriz no están disponibles para la tarea de continuación mediante el control estructurado de excepciones. Puede determinar qué excepciones se generaron examinando la Task.Exception propiedad de cada tarea de la tasks matriz. Para usar el control de excepciones estructurado para controlar las excepciones producidas por las tareas de la tasks matriz, llame al Task.WaitAll(Task[]) método .

Consulte también

Se aplica a

ContinueWhenAll(Task[], Action<Task[]>, CancellationToken)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
 System::Threading::Tasks::Task ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Action<cli::array <System::Threading::Tasks::Task ^> ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task ContinueWhenAll (System.Threading.Tasks.Task[] tasks, Action<System.Threading.Tasks.Task[]> continuationAction, System.Threading.CancellationToken cancellationToken);

member this.ContinueWhenAll : System.Threading.Tasks.Task[] * Action<System.Threading.Tasks.Task[]> * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function ContinueWhenAll (tasks As Task(), continuationAction As Action(Of Task()), cancellationToken As CancellationToken) As Task

Parámetros

tasks: Task[]

Matriz de tareas desde la que se va a continuar.

continuationAction: Action<Task[]>

Delegado de acción que se va a ejecutar cuando se completen todas las tareas de la matriz tasks.

cancellationToken: CancellationToken

Token de cancelación que se va a asignar a la nueva tarea de continuación.

Devoluciones

Task

Nueva tarea de continuación.

Excepciones

ObjectDisposedException

Un elemento de la matriz tasks se ha desechado.

O bien El CancellationTokenSource que creó cancellationToken ya se ha eliminado.

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationAction es null.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

Ejemplos

En el ejemplo siguiente se crea un token de cancelación, que pasa a tareas independientes que usan una expresión regular para contar el número de palabras de un conjunto de archivos de texto. El token de cancelación se establece si no se encuentra un archivo. El ContinueWhenAll(Task[], Action{Task[]}, CancellationToken) método se usa para iniciar una tarea que muestra el recuento total de palabras cuando se han completado todas las tareas anteriores. Si se establece el token de cancelación, que indica que se han cancelado una o varias tareas, controla la AggregateException excepción y muestra un mensaje de error.

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>();  
      CancellationTokenSource source = new CancellationTokenSource();
      CancellationToken token = source.Token;
      int totalWords = 0;
        
      // Determine the number of words in each file.
      foreach (var filename in filenames)
         tasks.Add( Task.Factory.StartNew( fn => { token.ThrowIfCancellationRequested(); 

                                                   if (! File.Exists(fn.ToString())) {
                                                      source.Cancel();
                                                      token.ThrowIfCancellationRequested();
                                                   }
                                                   
                                                   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, token));

      var finalTask = Task.Factory.ContinueWhenAll(tasks.ToArray(), wordCountTasks => {
                                                    if (! token.IsCancellationRequested) 
                                                       Console.WriteLine("\n{0,-25} {1,6} total words\n", 
                                                                         String.Format("{0} files", wordCountTasks.Length), 
                                                                         totalWords); 
                                                   }, token); 
      try {                                                   
         finalTask.Wait();
      }
      catch (AggregateException ae) {
         foreach (Exception inner in ae.InnerExceptions)
            if (inner is TaskCanceledException)
               Console.WriteLine("\nFailure to determine total word count: a task was cancelled.");
            else
               Console.WriteLine("\nFailure caused by {0}", inner.GetType().Name);      
      }
      finally {
         source.Dispose();
      }
   }
}
// The example displays output like the following:
//       chapter2.txt               1,585 words
//       chapter1.txt               4,012 words
//       
//       Failure to determine total word count: a task was cancelled.

Imports System.Collections.Generic
Imports System.IO
Imports System.Threading
Imports System.Threading.Tasks
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim filenames() As String= { "chapter1.txt", "chapter2.txt", 
                                   "chapter3.txt", "chapter4.txt",
                                   "chapter5.txt" }
      Dim pattern As String = "\b\w+\b"
      Dim tasks As New List(Of Task)()  
      Dim source As New CancellationTokenSource()
      Dim token As CancellationToken = source.Token
      Dim totalWords As Integer = 0
        
      ' Determine the number of words in each file.
      For Each filename In filenames
         tasks.Add( Task.Factory.StartNew( Sub(obj As Object)
                                              Dim fn As String = CStr(obj)
                                              token.ThrowIfCancellationRequested() 
                                              If Not File.Exists(fn) Then 
                                                 source.Cancel()
                                                 token.ThrowIfCancellationRequested()
                                              End If        
                                                   
                                              Dim sr As New StreamReader(fn.ToString())
                                              Dim content As String = sr.ReadToEnd()
                                              sr.Close()
                                              Dim words As Integer = Regex.Matches(content, pattern).Count
                                              Interlocked.Add(totalWords, words) 
                                              Console.WriteLine("{0,-25} {1,6:N0} words", fn, words) 
                                           End Sub, filename, token))
      Next
      
      Dim finalTask As Task = Task.Factory.ContinueWhenAll(tasks.ToArray(), 
                                                           Sub(wordCountTasks As Task())
                                                              If Not token.IsCancellationRequested Then 
                                                                 Console.WriteLine("\n{0,-25} {1,6} total words\n", 
                                                                                   String.Format("{0} files", wordCountTasks.Length), 
                                                                                   totalWords)
                                                              End If                      
                                                           End Sub, token) 
      Try                                                    
         finalTask.Wait()
      Catch ae As AggregateException 
         For Each inner In ae.InnerExceptions
            Console.WriteLine()
            If TypeOf inner Is TaskCanceledException
               Console.WriteLine("Failure to determine total word count: a task was cancelled.")
            Else
               Console.WriteLine("Failure caused by {0}", inner.GetType().Name)
            End If 
         Next           
      Finally
         source.Dispose()
      End Try                                                                     
   End Sub
End Module
' The example displays output like the following:
'       chapter2.txt               1,585 words
'       chapter1.txt               4,012 words
'       
'       Failure to determine total word count: a task was cancelled.

Comentarios

Este método ejecuta el continuationAction delegado cuando se han completado todas las tareas de la tasks matriz, independientemente de su estado de finalización.

Consulte también

Se aplica a

ContinueWhenAll(Task[], Action<Task[]>, TaskContinuationOptions)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
 System::Threading::Tasks::Task ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Action<cli::array <System::Threading::Tasks::Task ^> ^> ^ continuationAction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task ContinueWhenAll (System.Threading.Tasks.Task[] tasks, Action<System.Threading.Tasks.Task[]> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

member this.ContinueWhenAll : System.Threading.Tasks.Task[] * Action<System.Threading.Tasks.Task[]> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task

Public Function ContinueWhenAll (tasks As Task(), continuationAction As Action(Of Task()), continuationOptions As TaskContinuationOptions) As Task

Parámetros

tasks: Task[]

Matriz de tareas desde la que se va a continuar.

continuationAction: Action<Task[]>

Delegado de acción que se va a ejecutar cuando se completen todas las tareas de la matriz tasks.

continuationOptions: TaskContinuationOptions

Combinación bit a bit de los valores de enumeración que controlan el comportamiento de la nueva tarea de continuación. No se admiten los miembros NotOn* y OnlyOn*.

Devoluciones

Task

Nueva tarea de continuación.

Excepciones

ObjectDisposedException

Un elemento de la matriz tasks se ha desechado.

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationAction es null.

ArgumentOutOfRangeException

El argumento continuationOptions especifica un valor no válido.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

Comentarios

NotOn* y OnlyOn TaskContinuationOptions* , que restringen para qué TaskStatus estados se ejecutará una continuación, no son válidos con ContinueWhenAll.

Consulte también

Se aplica a

ContinueWhenAll(Task[], Action<Task[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
 System::Threading::Tasks::Task ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Action<cli::array <System::Threading::Tasks::Task ^> ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task ContinueWhenAll (System.Threading.Tasks.Task[] tasks, Action<System.Threading.Tasks.Task[]> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWhenAll : System.Threading.Tasks.Task[] * Action<System.Threading.Tasks.Task[]> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function ContinueWhenAll (tasks As Task(), continuationAction As Action(Of Task()), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task

Parámetros

tasks: Task[]

Matriz de tareas desde la que se va a continuar.

continuationAction: Action<Task[]>

Delegado de acción que se va a ejecutar cuando se completen todas las tareas de la matriz tasks.

cancellationToken: CancellationToken

Token de cancelación que se va a asignar a la nueva tarea de continuación.

continuationOptions: TaskContinuationOptions

Combinación bit a bit de los valores de enumeración que controlan el comportamiento de la nueva tarea de continuación.

scheduler: TaskScheduler

Objeto que se usa para programar la nueva tarea de continuación.

Devoluciones

Task

Nueva tarea de continuación.

Excepciones

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationAction es null.

O bien El argumento scheduler es null.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

ArgumentOutOfRangeException

continuationOptions especifica un valor TaskContinuationOptions no válido.

ObjectDisposedException

Ya se eliminó el CancellationToken proporcionado.

Comentarios

NotOn* y OnlyOn TaskContinuationOptions* , que restringen para qué TaskStatus estados se ejecutará una continuación, no son válidos con ContinueWhenAll.

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
generic <typename TAntecedentResult, typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Func<cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> ContinueWhenAll<TAntecedentResult,TResult> (System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Func<System.Threading.Tasks.Task<TAntecedentResult>[],TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWhenAll : System.Threading.Tasks.Task<'AntecedentResult>[] * Func<System.Threading.Tasks.Task<'AntecedentResult>[], 'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAll(Of TAntecedentResult, TResult) (tasks As Task(Of TAntecedentResult)(), continuationFunction As Func(Of Task(Of TAntecedentResult)(), TResult), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task(Of TResult)

Parámetros de tipo

TAntecedentResult

Tipo del resultado del parámetro tasks precedente.

TResult

Tipo del resultado devuelto por el delegado de continuationFunction y asociado a la tarea creada.

Parámetros

tasks: Task<TAntecedentResult>[]

Matriz de tareas desde la que se va a continuar.

continuationFunction: Func<Task<TAntecedentResult>[],TResult>

Delegado de función que se va a ejecutar asincrónicamente cuando se completen todas las tareas de la matriz tasks.

cancellationToken: CancellationToken

Token de cancelación que se va a asignar a la nueva tarea de continuación.

continuationOptions: TaskContinuationOptions

Combinación bit a bit de los valores de enumeración que controlan el comportamiento de la nueva tarea de continuación. No se admiten los miembros NotOn* y OnlyOn*.

scheduler: TaskScheduler

Objeto que se usa para programar la nueva tarea de continuación.

Devoluciones

Task<TResult>

Nueva tarea de continuación.

Excepciones

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationFunction es null.

O bien El argumento scheduler es null.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

ArgumentOutOfRangeException

El argumento continuationOptions especifica un valor no válido.

ObjectDisposedException

Un elemento de la matriz tasks se ha desechado.

O bien El CancellationTokenSource que creó cancellationToken ya se ha eliminado.

Comentarios

NotOn* y OnlyOn TaskContinuationOptions* , que restringen para qué TaskStatus estados se ejecutará una continuación, son ilegales con ContinueWhenAll.

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, TaskContinuationOptions)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
generic <typename TAntecedentResult, typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Func<cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^, TResult> ^ continuationFunction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task<TResult> ContinueWhenAll<TAntecedentResult,TResult> (System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Func<System.Threading.Tasks.Task<TAntecedentResult>[],TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

member this.ContinueWhenAll : System.Threading.Tasks.Task<'AntecedentResult>[] * Func<System.Threading.Tasks.Task<'AntecedentResult>[], 'Result> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAll(Of TAntecedentResult, TResult) (tasks As Task(Of TAntecedentResult)(), continuationFunction As Func(Of Task(Of TAntecedentResult)(), TResult), continuationOptions As TaskContinuationOptions) As Task(Of TResult)

Parámetros de tipo

TAntecedentResult

Tipo del resultado del parámetro tasks precedente.

TResult

Tipo del resultado devuelto por el delegado de continuationFunction y asociado a la tarea creada.

Parámetros

tasks: Task<TAntecedentResult>[]

Matriz de tareas desde la que se va a continuar.

continuationFunction: Func<Task<TAntecedentResult>[],TResult>

Delegado de función que se va a ejecutar asincrónicamente cuando se completen todas las tareas de la matriz tasks.

continuationOptions: TaskContinuationOptions

Combinación bit a bit de los valores de enumeración que controlan el comportamiento de la nueva tarea de continuación. No se admiten los miembros NotOn* y OnlyOn*.

Devoluciones

Task<TResult>

Nueva tarea de continuación.

Excepciones

ObjectDisposedException

Un elemento de la matriz tasks se ha desechado.

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationFunction es null.

ArgumentOutOfRangeException

El argumento continuationOptions especifica un valor no válido.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

Comentarios

NotOn* y OnlyOn TaskContinuationOptions* , que restringen para qué TaskStatus estados se ejecutará una continuación, son ilegales con ContinueWhenAll.

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
generic <typename TAntecedentResult, typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Func<cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> ContinueWhenAll<TAntecedentResult,TResult> (System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Func<System.Threading.Tasks.Task<TAntecedentResult>[],TResult> continuationFunction, System.Threading.CancellationToken cancellationToken);

member this.ContinueWhenAll : System.Threading.Tasks.Task<'AntecedentResult>[] * Func<System.Threading.Tasks.Task<'AntecedentResult>[], 'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAll(Of TAntecedentResult, TResult) (tasks As Task(Of TAntecedentResult)(), continuationFunction As Func(Of Task(Of TAntecedentResult)(), TResult), cancellationToken As CancellationToken) As Task(Of TResult)

Parámetros de tipo

TAntecedentResult

Tipo del resultado del parámetro tasks precedente.

TResult

Tipo del resultado devuelto por el delegado de continuationFunction y asociado a la tarea creada.

Parámetros

tasks: Task<TAntecedentResult>[]

Matriz de tareas desde la que se va a continuar.

continuationFunction: Func<Task<TAntecedentResult>[],TResult>

Delegado de función que se va a ejecutar asincrónicamente cuando se completen todas las tareas de la matriz tasks.

cancellationToken: CancellationToken

Token de cancelación que se va a asignar a la nueva tarea de continuación.

Devoluciones

Task<TResult>

Nueva tarea de continuación.

Excepciones

ObjectDisposedException

Un elemento de la matriz tasks se ha desechado.

O bien El CancellationTokenSource que creó cancellationToken ya se ha eliminado.

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationFunction es null.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
generic <typename TAntecedentResult, typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Func<cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^, TResult> ^ continuationFunction);

public System.Threading.Tasks.Task<TResult> ContinueWhenAll<TAntecedentResult,TResult> (System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Func<System.Threading.Tasks.Task<TAntecedentResult>[],TResult> continuationFunction);

member this.ContinueWhenAll : System.Threading.Tasks.Task<'AntecedentResult>[] * Func<System.Threading.Tasks.Task<'AntecedentResult>[], 'Result> -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAll(Of TAntecedentResult, TResult) (tasks As Task(Of TAntecedentResult)(), continuationFunction As Func(Of Task(Of TAntecedentResult)(), TResult)) As Task(Of TResult)

Parámetros de tipo

TAntecedentResult

Tipo del resultado del parámetro tasks precedente.

TResult

Tipo del resultado devuelto por el delegado de continuationFunction y asociado a la tarea creada.

Parámetros

tasks: Task<TAntecedentResult>[]

Matriz de tareas desde la que se va a continuar.

continuationFunction: Func<Task<TAntecedentResult>[],TResult>

Delegado de función que se va a ejecutar asincrónicamente cuando se completen todas las tareas de la matriz tasks.

Devoluciones

Task<TResult>

Nueva tarea de continuación.

Excepciones

ObjectDisposedException

Un elemento de la matriz tasks se ha desechado.

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationFunction es null.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
generic <typename TAntecedentResult>
 System::Threading::Tasks::Task ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Action<cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task ContinueWhenAll<TAntecedentResult> (System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Action<System.Threading.Tasks.Task<TAntecedentResult>[]> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWhenAll : System.Threading.Tasks.Task<'AntecedentResult>[] * Action<System.Threading.Tasks.Task<'AntecedentResult>[]> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task

Public Function ContinueWhenAll(Of TAntecedentResult) (tasks As Task(Of TAntecedentResult)(), continuationAction As Action(Of Task(Of TAntecedentResult)()), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task

Parámetros de tipo

TAntecedentResult

Tipo del resultado del parámetro tasks precedente.

Parámetros

tasks: Task<TAntecedentResult>[]

Matriz de tareas desde la que se va a continuar.

continuationAction: Action<Task<TAntecedentResult>[]>

Delegado de acción que se va a ejecutar cuando se completen todas las tareas de la matriz tasks.

cancellationToken: CancellationToken

Token de cancelación que se va a asignar a la nueva tarea de continuación.

continuationOptions: TaskContinuationOptions

Combinación bit a bit de los valores de enumeración que controlan el comportamiento de la nueva tarea de continuación. No se admiten los miembros NotOn* y OnlyOn*.

scheduler: TaskScheduler

Objeto que se usa para programar la nueva tarea de continuación.

Devoluciones

Task

Nueva tarea de continuación.

Excepciones

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationAction es null.

O bien El argumento scheduler es null.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

ArgumentOutOfRangeException

continuationOptions especifica un valor TaskContinuationOptions no válido.

ObjectDisposedException

Ya se eliminó el CancellationToken proporcionado.

Comentarios

NotOn* y OnlyOn TaskContinuationOptions* , que restringen para qué TaskStatus estados se ejecutará una continuación, no son válidos con ContinueWhenAll.

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, TaskContinuationOptions)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
generic <typename TAntecedentResult>
 System::Threading::Tasks::Task ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Action<cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^> ^ continuationAction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task ContinueWhenAll<TAntecedentResult> (System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Action<System.Threading.Tasks.Task<TAntecedentResult>[]> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

member this.ContinueWhenAll : System.Threading.Tasks.Task<'AntecedentResult>[] * Action<System.Threading.Tasks.Task<'AntecedentResult>[]> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task

Public Function ContinueWhenAll(Of TAntecedentResult) (tasks As Task(Of TAntecedentResult)(), continuationAction As Action(Of Task(Of TAntecedentResult)()), continuationOptions As TaskContinuationOptions) As Task

Parámetros de tipo

TAntecedentResult

Tipo del resultado del parámetro tasks precedente.

Parámetros

tasks: Task<TAntecedentResult>[]

Matriz de tareas desde la que se va a continuar.

continuationAction: Action<Task<TAntecedentResult>[]>

Delegado de acción que se va a ejecutar cuando se completen todas las tareas de la matriz tasks.

continuationOptions: TaskContinuationOptions

Combinación bit a bit de los valores de enumeración que controlan el comportamiento de la nueva tarea de continuación. No se admiten los miembros NotOn* y OnlyOn*.

Devoluciones

Task

Nueva tarea de continuación.

Excepciones

ObjectDisposedException

Un elemento de la matriz tasks se ha desechado.

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationAction es null.

ArgumentOutOfRangeException

El argumento continuationOptions especifica un valor no válido.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

Comentarios

NotOn* y OnlyOn TaskContinuationOptions* , que restringen para qué TaskStatus estados se ejecutará una continuación, no son válidos con ContinueWhenAll.

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
generic <typename TAntecedentResult>
 System::Threading::Tasks::Task ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Action<cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task ContinueWhenAll<TAntecedentResult> (System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Action<System.Threading.Tasks.Task<TAntecedentResult>[]> continuationAction, System.Threading.CancellationToken cancellationToken);

member this.ContinueWhenAll : System.Threading.Tasks.Task<'AntecedentResult>[] * Action<System.Threading.Tasks.Task<'AntecedentResult>[]> * System.Threading.CancellationToken -> System.Threading.Tasks.Task

Public Function ContinueWhenAll(Of TAntecedentResult) (tasks As Task(Of TAntecedentResult)(), continuationAction As Action(Of Task(Of TAntecedentResult)()), cancellationToken As CancellationToken) As Task

Parámetros de tipo

TAntecedentResult

Tipo del resultado del parámetro tasks precedente.

Parámetros

tasks: Task<TAntecedentResult>[]

Matriz de tareas desde la que se va a continuar.

continuationAction: Action<Task<TAntecedentResult>[]>

Delegado de acción que se va a ejecutar cuando se completen todas las tareas de la matriz tasks.

cancellationToken: CancellationToken

Token de cancelación que se va a asignar a la nueva tarea de continuación.

Devoluciones

Task

Nueva tarea de continuación.

Excepciones

ObjectDisposedException

Un elemento de la matriz tasks se ha desechado.

O bien El CancellationTokenSource que creó cancellationToken ya se ha eliminado.

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationAction es null.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
generic <typename TAntecedentResult>
 System::Threading::Tasks::Task ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^ tasks, Action<cli::array <System::Threading::Tasks::Task<TAntecedentResult> ^> ^> ^ continuationAction);

public System.Threading.Tasks.Task ContinueWhenAll<TAntecedentResult> (System.Threading.Tasks.Task<TAntecedentResult>[] tasks, Action<System.Threading.Tasks.Task<TAntecedentResult>[]> continuationAction);

member this.ContinueWhenAll : System.Threading.Tasks.Task<'AntecedentResult>[] * Action<System.Threading.Tasks.Task<'AntecedentResult>[]> -> System.Threading.Tasks.Task

Public Function ContinueWhenAll(Of TAntecedentResult) (tasks As Task(Of TAntecedentResult)(), continuationAction As Action(Of Task(Of TAntecedentResult)())) As Task

Parámetros de tipo

TAntecedentResult

Tipo del resultado del parámetro tasks precedente.

Parámetros

tasks: Task<TAntecedentResult>[]

Matriz de tareas desde la que se va a continuar.

continuationAction: Action<Task<TAntecedentResult>[]>

Delegado de acción que se va a ejecutar cuando se completen todas las tareas de la matriz tasks.

Devoluciones

Task

Nueva tarea de continuación.

Excepciones

ObjectDisposedException

Un elemento de la matriz tasks se ha desechado.

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationAction es null.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

Consulte también

Se aplica a

ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Func<cli::array <System::Threading::Tasks::Task ^> ^, TResult> ^ continuationFunction);

public System.Threading.Tasks.Task<TResult> ContinueWhenAll<TResult> (System.Threading.Tasks.Task[] tasks, Func<System.Threading.Tasks.Task[],TResult> continuationFunction);

member this.ContinueWhenAll : System.Threading.Tasks.Task[] * Func<System.Threading.Tasks.Task[], 'Result> -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAll(Of TResult) (tasks As Task(), continuationFunction As Func(Of Task(), TResult)) As Task(Of TResult)

Parámetros de tipo

TResult

Tipo del resultado devuelto por el delegado de continuationFunction y asociado a la tarea creada.

Parámetros

tasks: Task[]

Matriz de tareas desde la que se va a continuar.

continuationFunction: Func<Task[],TResult>

Delegado de función que se va a ejecutar asincrónicamente cuando se completen todas las tareas de la matriz tasks.

Devoluciones

Task<TResult>

Nueva tarea de continuación.

Excepciones

ObjectDisposedException

Un elemento de la matriz tasks se ha desechado.

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationFunction es null.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

Consulte también

Se aplica a

ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Func<cli::array <System::Threading::Tasks::Task ^> ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken);

public System.Threading.Tasks.Task<TResult> ContinueWhenAll<TResult> (System.Threading.Tasks.Task[] tasks, Func<System.Threading.Tasks.Task[],TResult> continuationFunction, System.Threading.CancellationToken cancellationToken);

member this.ContinueWhenAll : System.Threading.Tasks.Task[] * Func<System.Threading.Tasks.Task[], 'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAll(Of TResult) (tasks As Task(), continuationFunction As Func(Of Task(), TResult), cancellationToken As CancellationToken) As Task(Of TResult)

Parámetros de tipo

TResult

Tipo del resultado devuelto por el delegado de continuationFunction y asociado a la tarea creada.

Parámetros

tasks: Task[]

Matriz de tareas desde la que se va a continuar.

continuationFunction: Func<Task[],TResult>

Delegado de función que se va a ejecutar asincrónicamente cuando se completen todas las tareas de la matriz tasks.

cancellationToken: CancellationToken

Token de cancelación que se va a asignar a la nueva tarea de continuación.

Devoluciones

Task<TResult>

Nueva tarea de continuación.

Excepciones

ObjectDisposedException

Un elemento de la matriz tasks se ha desechado.

O bien El CancellationTokenSource que creó cancellationToken ya se ha eliminado.

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationFunction es null.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

Consulte también

Se aplica a

ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, TaskContinuationOptions)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Func<cli::array <System::Threading::Tasks::Task ^> ^, TResult> ^ continuationFunction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);

public System.Threading.Tasks.Task<TResult> ContinueWhenAll<TResult> (System.Threading.Tasks.Task[] tasks, Func<System.Threading.Tasks.Task[],TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

member this.ContinueWhenAll : System.Threading.Tasks.Task[] * Func<System.Threading.Tasks.Task[], 'Result> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAll(Of TResult) (tasks As Task(), continuationFunction As Func(Of Task(), TResult), continuationOptions As TaskContinuationOptions) As Task(Of TResult)

Parámetros de tipo

TResult

Tipo del resultado devuelto por el delegado de continuationFunction y asociado a la tarea creada.

Parámetros

tasks: Task[]

Matriz de tareas desde la que se va a continuar.

continuationFunction: Func<Task[],TResult>

Delegado de función que se va a ejecutar asincrónicamente cuando se completen todas las tareas de la matriz tasks.

continuationOptions: TaskContinuationOptions

Combinación bit a bit de los valores de enumeración que controlan el comportamiento de la nueva tarea de continuación. No se admiten los miembros NotOn* y OnlyOn*.

Devoluciones

Task<TResult>

Nueva tarea de continuación.

Excepciones

ObjectDisposedException

Un elemento de la matriz tasks se ha desechado.

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationFunction es null.

ArgumentOutOfRangeException

El argumento continuationOptions especifica un valor no válido.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

Comentarios

NotOn* y OnlyOn TaskContinuationOptions* , que restringen para qué TaskStatus estados se ejecutará una continuación, no son válidos con ContinueWhenAll.

Consulte también

Se aplica a

ContinueWhenAll<TResult>(Task[], Func<Task[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una tarea de continuación que comienza cuando un conjunto de tareas especificadas se ha completado.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWhenAll(cli::array <System::Threading::Tasks::Task ^> ^ tasks, Func<cli::array <System::Threading::Tasks::Task ^> ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);

public System.Threading.Tasks.Task<TResult> ContinueWhenAll<TResult> (System.Threading.Tasks.Task[] tasks, Func<System.Threading.Tasks.Task[],TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);

member this.ContinueWhenAll : System.Threading.Tasks.Task[] * Func<System.Threading.Tasks.Task[], 'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>

Public Function ContinueWhenAll(Of TResult) (tasks As Task(), continuationFunction As Func(Of Task(), TResult), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task(Of TResult)

Parámetros de tipo

TResult

Tipo del resultado devuelto por el delegado de continuationFunction y asociado a la tarea creada.

Parámetros

tasks: Task[]

Matriz de tareas desde la que se va a continuar.

continuationFunction: Func<Task[],TResult>

Delegado de función que se va a ejecutar asincrónicamente cuando se completen todas las tareas de la matriz tasks.

cancellationToken: CancellationToken

Token de cancelación que se va a asignar a la nueva tarea de continuación.

continuationOptions: TaskContinuationOptions

Combinación bit a bit de los valores de enumeración que controlan el comportamiento de la nueva tarea de continuación. No se admiten los miembros NotOn* y OnlyOn*.

scheduler: TaskScheduler

Objeto que se usa para programar la nueva tarea de continuación.

Devoluciones

Task<TResult>

Nueva tarea de continuación.

Excepciones

ArgumentNullException

La matriz tasks está null.

O bien El argumento continuationFunction es null.

O bien El argumento scheduler es null.

ArgumentException

La matriz tasks está vacía o contiene un valor null.

ArgumentOutOfRangeException

continuationOptions especifica un valor TaskContinuationOptions no válido.

ObjectDisposedException

Ya se eliminó el CancellationToken proporcionado.

Comentarios

NotOn* y OnlyOn TaskContinuationOptions* , que restringen para qué TaskStatus estados se ejecutará una continuación, no son válidos con ContinueWhenAll.

Consulte también

Se aplica a

Compartir a través de

TaskFactory.ContinueWhenAll Método

Definición

Sobrecargas

ContinueWhenAll(Task[], Action<Task[]>)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

ContinueWhenAll(Task[], Action<Task[]>, CancellationToken)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

ContinueWhenAll(Task[], Action<Task[]>, TaskContinuationOptions)

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a

ContinueWhenAll(Task[], Action<Task[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Parámetros de tipo

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, TaskContinuationOptions)

Parámetros de tipo

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken)

Parámetros de tipo

Parámetros

Devoluciones

Excepciones

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>)

Parámetros de tipo

Parámetros

Devoluciones

Excepciones

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Parámetros de tipo

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a

ContinueWhenAll<TAntecedentResult>(Task<TAntecedentResult>[], Action<Task<TAntecedentResult>[]>, TaskContinuationOptions)

Parámetros de tipo

Parámetros

Devoluciones

Excepciones

Comentarios

Consulte también

Se aplica a