Task.ContinueWith Método

Definición

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino.

Sobrecargas

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y un token de cancelación y que se ejecuta cuando el elemento Task de destino se completa. La continuación se ejecuta según un conjunto de condiciones especificadas y usa un programador especificado.

ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que se ejecuta cuando se completa la tarea de destino según el elemento TaskContinuationOptions especificado. La continuación recibe un token de cancelación y usa un programador especificado.

ContinueWith(Action<Task,Object>, Object, TaskScheduler)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta de forma asincrónica cuando el elemento Task de destino se completa. La continuación usa un programador especificado.

ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta cuando el elemento Task de destino se completa. La continuación se ejecuta según un conjunto de condiciones especificadas.

ContinueWith(Action<Task,Object>, Object, CancellationToken)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y un token de cancelación y que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa.

ContinueWith(Action<Task,Object>, Object)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta cuando el elemento Task de destino se completa.

ContinueWith(Action<Task>, TaskContinuationOptions)

Crea una continuación que se ejecuta cuando se completa la tarea de destino según el elemento TaskContinuationOptions especificado.

ContinueWith(Action<Task>, CancellationToken)

Crea una continuación que recibe un token de cancelación y se ejecuta de forma asincrónica cuando el elemento Task de destino se completa.

ContinueWith(Action<Task>)

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino.

ContinueWith(Action<Task>, TaskScheduler)

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino. La continuación usa un programador especificado.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)

Crea una continuación que se ejecuta según las opciones de continuación de la tarea especificadas cuando el elemento Task de destino se completa. La continuación recibe información de estado proporcionada por el autor de la llamada.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que se ejecuta según las opciones de continuación de la tarea especificadas cuando el elemento Task de destino se completa y devuelve un valor. La continuación recibe información de estado proporcionada por el autor de la llamada y un token de cancelación y usa el programador especificado.

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que se ejecuta según las opciones de continuación especificadas y devuelve un valor. Se pasa un token de cancelación a la continuación y usa un programador especificado.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino. La continuación recibe información de estado proporcionada por el autor de la llamada y usa a un programador especificado.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor. La continuación recibe información de estado proporcionada por el autor de la llamada y un token de cancelación.

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor. La continuación recibe un token de cancelación.

ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)

Crea una continuación que se ejecuta según las opciones de continuación especificadas y devuelve un valor.

ContinueWith<TResult>(Func<Task,Object,TResult>, Object)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor.

ContinueWith<TResult>(Func<Task,TResult>)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task<TResult> de destino se completa y devuelve un valor.

ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor. La continuación usa un programador especificado.

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y un token de cancelación y que se ejecuta cuando el elemento Task de destino se completa. La continuación se ejecuta según un conjunto de condiciones especificadas y usa un programador especificado.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task

Parámetros

continuationAction
Action<Task,Object>

Acción que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, se pasarán al delegado la tarea completada y el objeto de estado proporcionado por el llamador como argumentos.

state
Object

Objeto que representa los datos que la acción de continuación va a usar.

cancellationToken
CancellationToken

El CancellationToken que se asignará a la nueva tarea de continuación.

continuationOptions
TaskContinuationOptions

Opciones para la programación y el comportamiento de la continuación. Incluye criterios, como OnlyOnCanceled, y opciones de ejecución, como ExecuteSynchronously.

scheduler
TaskScheduler

Objeto TaskScheduler que se va a asociar a la tarea de continuación y se va a usar para su ejecución.

Devoluciones

Task

Nuevo objeto Task de continuación.

Excepciones

El argumento scheduler es null.

El argumento continuationOptions especifica un valor no válido para TaskContinuationOptions.

Ya se eliminó el CancellationToken proporcionado.

Comentarios

El devuelto Task no se programará para su ejecución hasta que se haya completado la tarea actual. Si no se cumplen los criterios especificados a través del continuationOptions parámetro , la tarea de continuación se cancelará en lugar de programada.

Se aplica a

ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que se ejecuta cuando se completa la tarea de destino según el elemento TaskContinuationOptions especificado. La continuación recibe un token de cancelación y usa un programador especificado.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task), cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task

Parámetros

continuationAction
Action<Task>

Una acción para ejecutarse según el continuationOptionsespecificado. Cuando se ejecute, al delegado se le pasará la tarea completada como un argumento.

cancellationToken
CancellationToken

El CancellationToken que se asignará a la nueva tarea de continuación.

continuationOptions
TaskContinuationOptions

Opciones para la programación y el comportamiento de la continuación. Incluye criterios, como OnlyOnCanceled, y opciones de ejecución, como ExecuteSynchronously.

scheduler
TaskScheduler

Objeto TaskScheduler que se va a asociar a la tarea de continuación y se va a usar para su ejecución.

Devoluciones

Task

Nuevo objeto Task de continuación.

Excepciones

El CancellationTokenSource que creó el token ya se ha eliminado.

El argumento continuationAction es null.

O bien El argumento scheduler es null.

El argumento continuationOptions especifica un valor no válido para TaskContinuationOptions.

Ejemplos

A continuación se muestra un ejemplo de uso de ContinueWith para ejecutar el trabajo en segundo plano y en los subprocesos de la interfaz de usuario.

private void Button1_Click(object sender, EventArgs e)  
{  
   var backgroundScheduler = TaskScheduler.Default;  
   var uiScheduler = TaskScheduler.FromCurrentSynchronizationContext();  
   Task.Factory.StartNew(delegate { DoBackgroundComputation(); },  
                         backgroundScheduler).  
   ContinueWith(delegate { UpdateUI(); }, uiScheduler).  
                ContinueWith(delegate { DoAnotherBackgroundComputation(); },  
                             backgroundScheduler).  
                ContinueWith(delegate { UpdateUIAgain(); }, uiScheduler);  
}  
Private Sub Button1_Click(ByVal sender As System.Object,   
                          ByVal e As System.EventArgs) Handles Button1.Click  
   Dim backgroundScheduler = TaskScheduler.Default  
   Dim uiScheduler = TaskScheduler.FromCurrentSynchronizationContext()  

   Task.Factory.StartNew(Sub()  
                           DoBackgroundComputation()  
                         End Sub, backgroundScheduler).ContinueWith(Sub(t)  
                            UpdateUI()  
                         End Sub, uiScheduler).ContinueWith(Sub(t)  
                            DoAnotherBackgroundComputation()  
                         End Sub, backgroundScheduler).ContinueWith(Sub(t)  
                            UpdateUIAgain()  
                         End Sub, uiScheduler)  
End Sub  

Comentarios

El devuelto Task no se programará para su ejecución hasta que se haya completado la tarea actual. Si no se cumplen los criterios especificados a través del continuationOptions parámetro , la tarea de continuación se cancelará en lugar de programada.

Se aplica a

ContinueWith(Action<Task,Object>, Object, TaskScheduler)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta de forma asincrónica cuando el elemento Task de destino se completa. La continuación usa un programador especificado.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.Tasks.TaskScheduler scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, scheduler As TaskScheduler) As Task

Parámetros

continuationAction
Action<Task,Object>

Acción que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, se pasarán al delegado la tarea completada y el objeto de estado proporcionado por el llamador como argumentos.

state
Object

Objeto que representa los datos que la acción de continuación va a usar.

scheduler
TaskScheduler

Objeto TaskScheduler que se va a asociar a la tarea de continuación y se va a usar para su ejecución.

Devoluciones

Task

Nuevo objeto Task de continuación.

Excepciones

El argumento scheduler es null.

Comentarios

El devuelto Task no se programará para su ejecución hasta que se haya completado la tarea actual, independientemente de si se completa debido a que se ha completado correctamente, se produce un error debido a una excepción no controlada o se cierra temprano debido a la cancelación.

Se aplica a

ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta cuando el elemento Task de destino se completa. La continuación se ejecuta según un conjunto de condiciones especificadas.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::Tasks::TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, continuationOptions As TaskContinuationOptions) As Task

Parámetros

continuationAction
Action<Task,Object>

Acción que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, se pasarán al delegado la tarea completada y el objeto de estado proporcionado por el llamador como argumentos.

state
Object

Objeto que representa los datos que la acción de continuación va a usar.

continuationOptions
TaskContinuationOptions

Opciones para la programación y el comportamiento de la continuación. Incluye criterios, como OnlyOnCanceled, y opciones de ejecución, como ExecuteSynchronously.

Devoluciones

Task

Nuevo objeto Task de continuación.

Excepciones

El argumento continuationAction es null.

El argumento continuationOptions especifica un valor no válido para TaskContinuationOptions.

Comentarios

El devuelto Task no se programará para su ejecución hasta que se haya completado la tarea actual. Si no se cumplen los criterios de continuación especificados a través del continuationOptions parámetro , la tarea de continuación se cancelará en lugar de programada.

Se aplica a

ContinueWith(Action<Task,Object>, Object, CancellationToken)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y un token de cancelación y que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state, System.Threading.CancellationToken cancellationToken);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object, cancellationToken As CancellationToken) As Task

Parámetros

continuationAction
Action<Task,Object>

Acción que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, se pasarán al delegado la tarea completada y el objeto de estado proporcionado por el llamador como argumentos.

state
Object

Objeto que representa los datos que la acción de continuación va a usar.

cancellationToken
CancellationToken

El CancellationToken que se asignará a la nueva tarea de continuación.

Devoluciones

Task

Nuevo objeto Task de continuación.

Excepciones

El argumento continuationAction es null.

Ya se eliminó el CancellationToken proporcionado.

Comentarios

El devuelto Task no se programará para su ejecución hasta que se haya completado la tarea actual, independientemente de si se completa debido a que se ha completado correctamente, se produce un error debido a una excepción no controlada o se cierra temprano debido a la cancelación.

Se aplica a

ContinueWith(Action<Task,Object>, Object)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta cuando el elemento Task de destino se completa.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^, System::Object ^> ^ continuationAction, System::Object ^ state);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object> continuationAction, object state);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state);
member this.ContinueWith : Action<System.Threading.Tasks.Task, obj> * obj -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task, Object), state As Object) As Task

Parámetros

continuationAction
Action<Task,Object>

Acción que se ejecutará cuando se complete la tarea. Cuando se ejecuta, se pasa al delegado la tarea completada y el objeto de estado proporcionado por el autor de la llamada como argumentos.

state
Object

Objeto que representa los datos que la acción de continuación va a usar.

Devoluciones

Task

Una tarea de continuación nueva.

Excepciones

El argumento continuationAction es null.

Comentarios

El devuelto Task no se programará para su ejecución hasta que se haya completado la tarea actual, independientemente de si se completa debido a la ejecución correcta, a errores debido a una excepción no controlada o a la salida anticipada debido a la cancelación.

Se aplica a

ContinueWith(Action<Task>, TaskContinuationOptions)

Crea una continuación que se ejecuta cuando se completa la tarea de destino según el elemento TaskContinuationOptions especificado.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task), continuationOptions As TaskContinuationOptions) As Task

Parámetros

continuationAction
Action<Task>

Una acción para ejecutarse según el continuationOptions especificado. Cuando se ejecute, al delegado se le pasará la tarea completada como un argumento.

continuationOptions
TaskContinuationOptions

Opciones para la programación y el comportamiento de la continuación. Incluye criterios, como OnlyOnCanceled, y opciones de ejecución, como ExecuteSynchronously.

Devoluciones

Task

Nuevo objeto Task de continuación.

Excepciones

El argumento continuationAction es null.

El argumento continuationOptions especifica un valor no válido para TaskContinuationOptions.

Ejemplos

En el ejemplo siguiente se muestra cómo usar TaskContinuationOptions para especificar que una tarea de continuación se debe ejecutar de forma sincrónica cuando se completa la tarea anterior. (Si la tarea especificada ya se ha completado en el momento ContinueWith en que se llama, la continuación sincrónica se ejecutará en el subproceso que llama ContinueWitha ).

public class TaskCounter  
{  
   private volatile int _count;  

   public void Track(Task t)  
   {  
      if (t == null) throw new ArgumentNullException("t");  
      Interlocked.Increment(ref _count);  
      t.ContinueWith(ct => Interlocked.Decrement(ref _count), TaskContinuationOptions.ExecuteSynchronously);  
   }  

   public int NumberOfActiveTasks { get { return _count; } }  
}  
Public Class TaskCounter  
   Private _count as Integer  

   Public Sub Track(ByVal t as Task)  
      If t is Nothing Then Throw New ArgumentNullException("t")  
      Interlocked.Increment(_count)  
      t.ContinueWith(Sub(ct)  
                        Interlocked.Decrement(_count)  
                     End Sub,  
                     TaskContinuationOptions.ExecuteSynchronously)  
   End Sub  

   Public ReadOnly Property NumberOfActiveTasks As Integer  
      Get  
         Return _count  
      End Get  
   End Property  
End Class  

Comentarios

El devuelto Task no se programará para su ejecución hasta que se haya completado la tarea actual. Si no se cumplen los criterios de continuación especificados a través del continuationOptions parámetro , la tarea de continuación se cancelará en lugar de programada.

Se aplica a

ContinueWith(Action<Task>, CancellationToken)

Crea una continuación que recibe un token de cancelación y se ejecuta de forma asincrónica cuando el elemento Task de destino se completa.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.CancellationToken -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task), cancellationToken As CancellationToken) As Task

Parámetros

continuationAction
Action<Task>

Acción que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, al delegado se le pasará la tarea completada como un argumento.

cancellationToken
CancellationToken

El CancellationToken que se asignará a la nueva tarea de continuación.

Devoluciones

Task

Nuevo objeto Task de continuación.

Excepciones

El CancellationTokenSource que creó el token ya se ha eliminado.

El argumento continuationAction es null.

Comentarios

El devuelto Task no se programará para su ejecución hasta que se haya completado la tarea actual, independientemente de si se completa debido a la ejecución correcta, a errores debido a una excepción no controlada o a la salida anticipada debido a que se canceló.

Se aplica a

ContinueWith(Action<Task>)

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction);
member this.ContinueWith : Action<System.Threading.Tasks.Task> -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task)) As Task

Parámetros

continuationAction
Action<Task>

Acción que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, al delegado se le pasará la tarea completada como un argumento.

Devoluciones

Task

Nuevo objeto Task de continuación.

Excepciones

El argumento continuationAction es null.

Ejemplos

En el ejemplo siguiente se define una tarea que rellena una matriz con 100 valores de fecha y hora aleatorios. Usa el ContinueWith(Action<Task>) método para seleccionar los valores de fecha más antiguos y más recientes una vez que la matriz se rellena por completo.

using System;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      var firstTask = Task.Factory.StartNew( () => {
                               Random rnd = new Random();
                               DateTime[] dates = new DateTime[100];
                               Byte[] buffer = new Byte[8];
                               int ctr = dates.GetLowerBound(0);
                               while (ctr <= dates.GetUpperBound(0)) {
                                  rnd.NextBytes(buffer);
                                  long ticks = BitConverter.ToInt64(buffer, 0);
                                  if (ticks <= DateTime.MinValue.Ticks | ticks >= DateTime.MaxValue.Ticks)
                                     continue;

                                  dates[ctr] = new DateTime(ticks);
                                  ctr++;
                               }
                               return dates;
                            } ); 
                         
      Task continuationTask = firstTask.ContinueWith( (antecedent) => {
                             DateTime[] dates = antecedent.Result;
                             DateTime earliest = dates[0];
                             DateTime latest = earliest;
                             
                             for (int ctr = dates.GetLowerBound(0) + 1; ctr <= dates.GetUpperBound(0); ctr++) {
                                if (dates[ctr] < earliest) earliest = dates[ctr];
                                if (dates[ctr] > latest) latest = dates[ctr];
                             }
                             Console.WriteLine("Earliest date: {0}", earliest);
                             Console.WriteLine("Latest date: {0}", latest);
                          } );                      
      // Since a console application otherwise terminates, wait for the continuation to complete.
     continuationTask.Wait();
   }
}
// The example displays output like the following:
//       Earliest date: 2/11/0110 12:03:41 PM
//       Latest date: 7/29/9989 2:14:49 PM
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim firstTask = Task.Factory.StartNew( Function()
                               Dim rnd As New Random()
                               Dim dates(99) As Date
                               Dim buffer(7) As Byte
                               Dim ctr As Integer = dates.GetLowerBound(0)
                               Do While ctr <= dates.GetUpperBound(0)
                                  rnd.NextBytes(buffer)
                                  Dim ticks As Long = BitConverter.ToInt64(buffer, 0)
                                  If ticks <= DateTime.MinValue.Ticks Or ticks >= DateTime.MaxValue.Ticks Then Continue Do

                                  dates(ctr) = New Date(ticks)
                                  ctr += 1
                               Loop
                               Return dates
                            End Function )
                         
      Dim continuationTask As Task = firstTask.ContinueWith( Sub(antecedent)
                             Dim dates() As Date = antecedent.Result
                             Dim earliest As Date = dates(0)
                             Dim latest As Date = earliest
                             
                             For ctr As Integer = dates.GetLowerBound(0) + 1 To dates.GetUpperBound(0)
                                If dates(ctr) < earliest Then earliest = dates(ctr)
                                If dates(ctr) > latest Then latest = dates(ctr)
                             Next
                             Console.WriteLine("Earliest date: {0}", earliest)
                             Console.WriteLine("Latest date: {0}", latest)
                          End Sub)                      
      ' Since a console application otherwise terminates, wait for the continuation to complete.
      continuationTask.Wait()
   End Sub
End Module
' The example displays output like the following:
'       Earliest date: 2/11/0110 12:03:41 PM
'       Latest date: 7/29/9989 2:14:49 PM

Dado que una aplicación de consola puede finalizar antes de que se ejecute la tarea de continuación, Wait() se llama al método para asegurarse de que la continuación termina de ejecutarse antes de que finalice el ejemplo.

Para obtener un ejemplo adicional, vea Encadenamiento de tareas mediante tareas de continuación.

Comentarios

El devuelto Task no se programará para su ejecución hasta que se haya completado la tarea actual, independientemente de si se completa debido a la ejecución correcta, a errores debido a una excepción no controlada o a la salida anticipada debido a que se canceló.

Se aplica a

ContinueWith(Action<Task>, TaskScheduler)

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino. La continuación usa un programador especificado.

public:
 System::Threading::Tasks::Task ^ ContinueWith(Action<System::Threading::Tasks::Task ^> ^ continuationAction, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Action<System.Threading.Tasks.Task> * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task
Public Function ContinueWith (continuationAction As Action(Of Task), scheduler As TaskScheduler) As Task

Parámetros

continuationAction
Action<Task>

Acción que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, al delegado se le pasará la tarea completada como un argumento.

scheduler
TaskScheduler

Objeto TaskScheduler que se va a asociar a la tarea de continuación y se va a usar para su ejecución.

Devoluciones

Task

Nuevo objeto Task de continuación.

Excepciones

Se ha eliminado Task.

El argumento continuationAction es null.

O bien El argumento scheduler es null.

Comentarios

El devuelto Task no se programará para su ejecución hasta que se haya completado la tarea actual, independientemente de si se completa debido a que se ha completado correctamente, se produce un error debido a una excepción no controlada o se cierra temprano debido a la cancelación.

Se aplica a

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)

Crea una continuación que se ejecuta según las opciones de continuación de la tarea especificadas cuando el elemento Task de destino se completa. La continuación recibe información de estado proporcionada por el autor de la llamada.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::Tasks::TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, continuationOptions As TaskContinuationOptions) As Task(Of TResult)

Parámetros de tipo

TResult

Tipo de resultado generado por la continuación.

Parámetros

continuationFunction
Func<Task,Object,TResult>

Función que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, se pasarán al delegado la tarea completada y el objeto de estado proporcionado por el llamador como argumentos.

state
Object

Objeto que representa los datos que la función de continuación va a usar.

continuationOptions
TaskContinuationOptions

Opciones para la programación y el comportamiento de la continuación. Incluye criterios, como OnlyOnCanceled, y opciones de ejecución, como ExecuteSynchronously.

Devoluciones

Task<TResult>

Nuevo objeto Task<TResult> de continuación.

Excepciones

El argumento continuationFunction es null.

El argumento continuationOptions especifica un valor no válido para TaskContinuationOptions.

Comentarios

El devuelto Task<TResult> no se programará para su ejecución hasta que se haya completado la tarea actual. Si no se cumplen los criterios de continuación especificados a través del continuationOptions parámetro , la tarea de continuación se cancelará en lugar de programada.

Se aplica a

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que se ejecuta según las opciones de continuación de la tarea especificadas cuando el elemento Task de destino se completa y devuelve un valor. La continuación recibe información de estado proporcionada por el autor de la llamada y un token de cancelación y usa el programador especificado.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::CancellationToken cancellationToken, System::Threading::Tasks::TaskContinuationOptions continuationOptions, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, cancellationToken As CancellationToken, continuationOptions As TaskContinuationOptions, scheduler As TaskScheduler) As Task(Of TResult)

Parámetros de tipo

TResult

Tipo de resultado generado por la continuación.

Parámetros

continuationFunction
Func<Task,Object,TResult>

Función que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, se pasarán al delegado la tarea completada y el objeto de estado proporcionado por el llamador como argumentos.

state
Object

Objeto que representa los datos que la función de continuación va a usar.

cancellationToken
CancellationToken

El CancellationToken que se asignará a la nueva tarea de continuación.

continuationOptions
TaskContinuationOptions

Opciones para la programación y el comportamiento de la continuación. Incluye criterios, como OnlyOnCanceled, y opciones de ejecución, como ExecuteSynchronously.

scheduler
TaskScheduler

Objeto TaskScheduler que se va a asociar a la tarea de continuación y se va a usar para su ejecución.

Devoluciones

Task<TResult>

Nuevo objeto Task<TResult> de continuación.

Excepciones

El argumento scheduler es null.

El argumento continuationOptions especifica un valor no válido para TaskContinuationOptions.

Ya se eliminó el CancellationToken proporcionado.

Comentarios

El devuelto Task<TResult> no se programará para su ejecución hasta que se haya completado la tarea actual. Si no se cumplen los criterios especificados a través del continuationOptions parámetro , la tarea de continuación se cancelará en lugar de programada.

Se aplica a

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

Crea una continuación que se ejecuta según las opciones de continuación especificadas y devuelve un valor. Se pasa un token de cancelación a la continuación y usa un programador especificado.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<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> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.CancellationToken * System.Threading.Tasks.TaskContinuationOptions * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (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 de resultado generado por la continuación.

Parámetros

continuationFunction
Func<Task,TResult>

Una función que se ejecutará según el parámetro continuationOptions especificado. Cuando se ejecute, al delegado se le pasará la tarea completada como un argumento.

cancellationToken
CancellationToken

El CancellationToken que se asignará a la nueva tarea de continuación.

continuationOptions
TaskContinuationOptions

Opciones para la programación y el comportamiento de la continuación. Incluye criterios, como OnlyOnCanceled, y opciones de ejecución, como ExecuteSynchronously.

scheduler
TaskScheduler

Objeto TaskScheduler que se va a asociar a la tarea de continuación y se va a usar para su ejecución.

Devoluciones

Task<TResult>

Nuevo objeto Task<TResult> de continuación.

Excepciones

Se ha eliminado Task.

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

El argumento continuationFunction es null.

O bien El argumento scheduler es null.

El argumento continuationOptions especifica un valor no válido para TaskContinuationOptions.

Ejemplos

En el ejemplo siguiente se muestra cómo usar el método ContinueWith con opciones de continuación:

using System;
using System.Threading;
using System.Threading.Tasks;

class ContinuationOptionsDemo
{
    // Demonstrated features:
    //      TaskContinuationOptions
    //		Task.ContinueWith()
    // 		Task.Factory
    //		Task.Wait()
    // Expected results:
    // 		This sample demonstrates branched continuation sequences - Task+Commit or Task+Rollback.
    //      Notice that no if statements are used.
    //		The first sequence is successful - tran1 and commitTran1 are executed. rollbackTran1 is canceled.
    //		The second sequence is unsuccessful - tran2 and rollbackTran2 are executed. tran2 is faulted, and commitTran2 is canceled.
    // Documentation:
    //		http://msdn.microsoft.com/library/system.threading.tasks.taskcontinuationoptions(VS.100).aspx
    static void Main()
    {
        Action success = () => Console.WriteLine("Task={0}, Thread={1}: Begin successful transaction",
                                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        Action failure = () =>
        {
            Console.WriteLine("Task={0}, Thread={1}: Begin transaction and encounter an error",
                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
            throw new InvalidOperationException("SIMULATED EXCEPTION");
        };

        Action<Task> commit = (antecendent) => Console.WriteLine("Task={0}, Thread={1}: Commit transaction",
                                                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        Action<Task> rollback = (antecendent) =>
        {
            // "Observe" your antecedent's exception so as to avoid an exception
            // being thrown on the finalizer thread
            var unused = antecendent.Exception;

            Console.WriteLine("Task={0}, Thread={1}: Rollback transaction",
                  Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        };

        // Successful transaction - Begin + Commit
        Console.WriteLine("Demonstrating a successful transaction");

        // Initial task
        // Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Task tran1 = Task.Factory.StartNew(success);

        // The following task gets scheduled only if tran1 completes successfully
        var commitTran1 = tran1.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion);

        // The following task gets scheduled only if tran1 DOES NOT complete successfully
        var rollbackTran1 = tran1.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion);

        // For demo purposes, wait for the sample to complete
        commitTran1.Wait();

        // -----------------------------------------------------------------------------------

        // Failed transaction - Begin + exception + Rollback
        Console.WriteLine("\nDemonstrating a failed transaction");

        // Initial task
        // Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Task tran2 = Task.Factory.StartNew(failure);

        // The following task gets scheduled only if tran2 completes successfully
        var commitTran2 = tran2.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion);

        // The following task gets scheduled only if tran2 DOES NOT complete successfully
        var rollbackTran2 = tran2.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion);

        // For demo purposes, wait for the sample to complete
        rollbackTran2.Wait();
    }
}
Imports System.Threading
Imports System.Threading.Tasks

Module ContuationOptionsDemo
    ' Demonstrated features:
    '   TaskContinuationOptions
    '   Task.ContinueWith()
    '   Task.Factory
    '   Task.Wait()
    ' Expected results:
    '   This sample demonstrates branched continuation sequences - Task+Commit or Task+Rollback.
    '   Notice that no if statements are used.
    '   The first sequence is successful - tran1 and commitTran1 are executed. rollbackTran1 is canceled.
    '   The second sequence is unsuccessful - tran2 and rollbackTran2 are executed. tran2 is faulted, and commitTran2 is canceled.
    ' Documentation:
    '   http://msdn.microsoft.com/library/system.threading.tasks.taskcontinuationoptions(VS.100).aspx
    Private Sub Main()
        Dim success As Action = Sub()
                                    Console.WriteLine("Task={0}, Thread={1}: Begin successful transaction", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                End Sub

        Dim failure As Action = Sub()
                                    Console.WriteLine("Task={0}, Thread={1}: Begin transaction and encounter an error", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                    Throw New InvalidOperationException("SIMULATED EXCEPTION")
                                End Sub

        Dim commit As Action(Of Task) = Sub(antecendent)
                                            Console.WriteLine("Task={0}, Thread={1}: Commit transaction", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                        End Sub

        Dim rollback As Action(Of Task) = Sub(antecendent)
                                              ' "Observe" your antecedent's exception so as to avoid an exception
                                              ' being thrown on the finalizer thread
                                              Dim unused = antecendent.Exception

                                              Console.WriteLine("Task={0}, Thread={1}: Rollback transaction", Task.CurrentId, Thread.CurrentThread.ManagedThreadId)
                                          End Sub

        ' Successful transaction - Begin + Commit
        Console.WriteLine("Demonstrating a successful transaction")

        ' Initial task
        ' Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Dim tran1 As Task = Task.Factory.StartNew(success)

        ' The following task gets scheduled only if tran1 completes successfully
        Dim commitTran1 = tran1.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion)

        ' The following task gets scheduled only if tran1 DOES NOT complete successfully
        Dim rollbackTran1 = tran1.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion)

        ' For demo purposes, wait for the sample to complete
        commitTran1.Wait()

        ' -----------------------------------------------------------------------------------


        ' Failed transaction - Begin + exception + Rollback 
        Console.WriteLine(vbLf & "Demonstrating a failed transaction")

        ' Initial task
        ' Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Dim tran2 As Task = Task.Factory.StartNew(failure)

        ' The following task gets scheduled only if tran2 completes successfully
        Dim commitTran2 = tran2.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion)

        ' The following task gets scheduled only if tran2 DOES NOT complete successfully
        Dim rollbackTran2 = tran2.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion)

        ' For demo purposes, wait for the sample to complete
        rollbackTran2.Wait()
    End Sub
End Module

Comentarios

El devuelto Task<TResult> no se programará para su ejecución hasta que se haya completado la tarea actual. Si no se cumplen los criterios especificados a través del continuationOptions parámetro , la tarea de continuación se cancelará en lugar de programada.

Se aplica a

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)

Crea una continuación que se ejecuta de manera asincrónica cuando se completa el objeto Task de destino. La continuación recibe información de estado proporcionada por el autor de la llamada y usa a un programador especificado.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.Tasks.TaskScheduler scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, scheduler As TaskScheduler) As Task(Of TResult)

Parámetros de tipo

TResult

Tipo de resultado generado por la continuación.

Parámetros

continuationFunction
Func<Task,Object,TResult>

Función que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, se pasarán al delegado la tarea completada y el objeto de estado proporcionado por el llamador como argumentos.

state
Object

Objeto que representa los datos que la función de continuación va a usar.

scheduler
TaskScheduler

Objeto TaskScheduler que se va a asociar a la tarea de continuación y se va a usar para su ejecución.

Devoluciones

Task<TResult>

Nuevo objeto Task<TResult> de continuación.

Excepciones

El argumento scheduler es null.

Comentarios

El devuelto Task<TResult> no se programará para su ejecución hasta que se haya completado la tarea actual, independientemente de si se completa debido a la ejecución correcta, a errores debido a una excepción no controlada o a la salida anticipada debido a que se canceló.

Se aplica a

ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor. La continuación recibe información de estado proporcionada por el autor de la llamada y un token de cancelación.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object, cancellationToken As CancellationToken) As Task(Of TResult)

Parámetros de tipo

TResult

Tipo de resultado generado por la continuación.

Parámetros

continuationFunction
Func<Task,Object,TResult>

Función que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, se pasarán al delegado la tarea completada y el objeto de estado proporcionado por el llamador como argumentos.

state
Object

Objeto que representa los datos que la función de continuación va a usar.

cancellationToken
CancellationToken

El CancellationToken que se asignará a la nueva tarea de continuación.

Devoluciones

Task<TResult>

Nuevo objeto Task<TResult> de continuación.

Excepciones

El argumento continuationFunction es null.

Ya se eliminó el CancellationToken proporcionado.

Comentarios

El devuelto Task<TResult> no se programará para su ejecución hasta que se haya completado la tarea actual, independientemente de si se completa debido a la ejecución correcta, a errores debido a una excepción no controlada o a la salida anticipada debido a que se canceló.

Se aplica a

ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor. La continuación recibe un token de cancelación.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::CancellationToken cancellationToken);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.CancellationToken -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), cancellationToken As CancellationToken) As Task(Of TResult)

Parámetros de tipo

TResult

Tipo de resultado generado por la continuación.

Parámetros

continuationFunction
Func<Task,TResult>

Función que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, al delegado se le pasará la tarea completada como un argumento.

cancellationToken
CancellationToken

El CancellationToken que se asignará a la nueva tarea de continuación.

Devoluciones

Task<TResult>

Nuevo objeto Task<TResult> de continuación.

Excepciones

Se ha eliminado Task.

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

El argumento continuationFunction es null.

Comentarios

El devuelto Task<TResult> no se programará para su ejecución hasta que se haya completado la tarea actual, independientemente de si se completa debido a la ejecución correcta, a errores debido a una excepción no controlada o a la salida anticipada debido a que se canceló.

Se aplica a

ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)

Crea una continuación que se ejecuta según las opciones de continuación especificadas y devuelve un valor.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::Tasks::TaskContinuationOptions continuationOptions);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.Tasks.TaskContinuationOptions -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), continuationOptions As TaskContinuationOptions) As Task(Of TResult)

Parámetros de tipo

TResult

Tipo de resultado generado por la continuación.

Parámetros

continuationFunction
Func<Task,TResult>

Una función para ejecutar según la condición especificada en continuationOptions. Cuando se ejecute, al delegado se le pasará la tarea completada como un argumento.

continuationOptions
TaskContinuationOptions

Opciones para la programación y el comportamiento de la continuación. Incluye criterios, como OnlyOnCanceled, y opciones de ejecución, como ExecuteSynchronously.

Devoluciones

Task<TResult>

Nuevo objeto Task<TResult> de continuación.

Excepciones

Se ha eliminado Task.

El argumento continuationFunction es null.

El argumento continuationOptions especifica un valor no válido para TaskContinuationOptions.

Comentarios

El devuelto Task<TResult> no se programará para su ejecución hasta que se haya completado la tarea actual. Si no se cumplen los criterios de continuación especificados a través del continuationOptions parámetro , la tarea de continuación se cancelará en lugar de programada.

Se aplica a

ContinueWith<TResult>(Func<Task,Object,TResult>, Object)

Crea una continuación que recibe información de estado proporcionada por el autor de la llamada y se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, System::Object ^, TResult> ^ continuationFunction, System::Object ^ state);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object,TResult> continuationFunction, object state);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state);
member this.ContinueWith : Func<System.Threading.Tasks.Task, obj, 'Result> * obj -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, Object, TResult), state As Object) As Task(Of TResult)

Parámetros de tipo

TResult

Tipo de resultado generado por la continuación.

Parámetros

continuationFunction
Func<Task,Object,TResult>

Función que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, se pasarán al delegado la tarea completada y el objeto de estado proporcionado por el llamador como argumentos.

state
Object

Objeto que representa los datos que la función de continuación va a usar.

Devoluciones

Task<TResult>

Nuevo objeto Task<TResult> de continuación.

Excepciones

El argumento continuationFunction es null.

Comentarios

El devuelto Task<TResult> no se programará para su ejecución hasta que se haya completado la tarea actual, independientemente de si se completa debido a que se ha completado correctamente, se produce un error debido a una excepción no controlada o se cierra temprano debido a la cancelación.

Se aplica a

ContinueWith<TResult>(Func<Task,TResult>)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task<TResult> de destino se completa y devuelve un valor.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult)) As Task(Of TResult)

Parámetros de tipo

TResult

Tipo de resultado generado por la continuación.

Parámetros

continuationFunction
Func<Task,TResult>

Función que se va a ejecutar cuando se complete el objeto Task<TResult>. Cuando se ejecute, al delegado se le pasará la tarea completada como un argumento.

Devoluciones

Task<TResult>

Una tarea de continuación nueva.

Excepciones

Se ha eliminado Task.

El argumento continuationFunction es null.

Ejemplos

En el ejemplo siguiente se muestra cómo usar el método ContinueWith:

using System;
using System.Threading;
using System.Threading.Tasks;

class ContinuationSimpleDemo
{
    // Demonstrated features:
    // 		Task.Factory
    //		Task.ContinueWith()
    //		Task.Wait()
    // Expected results:
    // 		A sequence of three unrelated tasks is created and executed in this order - alpha, beta, gamma.
    //		A sequence of three related tasks is created - each task negates its argument and passes is to the next task: 5, -5, 5 is printed.
    //		A sequence of three unrelated tasks is created where tasks have different types.
    // Documentation:
    //		http://msdn.microsoft.com/library/system.threading.tasks.taskfactory_members(VS.100).aspx
    static void Main()
    {
        Action<string> action =
            (str) =>
                Console.WriteLine("Task={0}, str={1}, Thread={2}", Task.CurrentId, str, Thread.CurrentThread.ManagedThreadId);

        // Creating a sequence of action tasks (that return no result).
        Console.WriteLine("Creating a sequence of action tasks (that return no result)");
        Task.Factory.StartNew(() => action("alpha"))
            .ContinueWith(antecendent => action("beta"))        // Antecedent data is ignored
            .ContinueWith(antecendent => action("gamma"))
            .Wait();

        Func<int, int> negate =
            (n) =>
            {
                Console.WriteLine("Task={0}, n={1}, -n={2}, Thread={3}", Task.CurrentId, n, -n, Thread.CurrentThread.ManagedThreadId);
                return -n;
            };

        // Creating a sequence of function tasks where each continuation uses the result from its antecendent
        Console.WriteLine("\nCreating a sequence of function tasks where each continuation uses the result from its antecendent");
        Task<int>.Factory.StartNew(() => negate(5))
            .ContinueWith(antecendent => negate(antecendent.Result))		// Antecedent result feeds into continuation
            .ContinueWith(antecendent => negate(antecendent.Result))
            .Wait();

        // Creating a sequence of tasks where you can mix and match the types
        Console.WriteLine("\nCreating a sequence of tasks where you can mix and match the types");
        Task<int>.Factory.StartNew(() => negate(6))
            .ContinueWith(antecendent => action("x"))
            .ContinueWith(antecendent => negate(7))
            .Wait();
    }
}
Imports System.Threading
Imports System.Threading.Tasks

Module ContinuationDemo

    ' Demonstrated features:
    '   Task.Factory
    '   Task.ContinueWith()
    '   Task.Wait()
    ' Expected results:
    '   A sequence of three unrelated tasks is created and executed in this order - alpha, beta, gamma.
    '   A sequence of three related tasks is created - each task negates its argument and passes is to the next task: 5, -5, 5 is printed.
    '   A sequence of three unrelated tasks is created where tasks have different types.
    ' Documentation:
    '   http://msdn.microsoft.com/library/system.threading.tasks.taskfactory_members(VS.100).aspx
    Sub Main()
        Dim action As Action(Of String) = Sub(str) Console.WriteLine("Task={0}, str={1}, Thread={2}", Task.CurrentId, str, Thread.CurrentThread.ManagedThreadId)

        ' Creating a sequence of action tasks (that return no result).
        Console.WriteLine("Creating a sequence of action tasks (that return no result)")
        ' Continuations ignore antecedent data
        Task.Factory.StartNew(Sub() action("alpha")).ContinueWith(Sub(antecendent) action("beta")).ContinueWith(Sub(antecendent) action("gamma")).Wait()


        Dim negate As Func(Of Integer, Integer) = Function(n)
                                                      Console.WriteLine("Task={0}, n={1}, -n={2}, Thread={3}", Task.CurrentId, n, -n, Thread.CurrentThread.ManagedThreadId)
                                                      Return -n
                                                  End Function

        ' Creating a sequence of function tasks where each continuation uses the result from its antecendent
        Console.WriteLine(vbLf & "Creating a sequence of function tasks where each continuation uses the result from its antecendent")
        Task(Of Integer).Factory.StartNew(Function() negate(5)).ContinueWith(Function(antecendent) negate(antecendent.Result)).ContinueWith(Function(antecendent) negate(antecendent.Result)).Wait()


        ' Creating a sequence of tasks where you can mix and match the types
        Console.WriteLine(vbLf & "Creating a sequence of tasks where you can mix and match the types")
        Task(Of Integer).Factory.StartNew(Function() negate(6)).ContinueWith(Sub(antecendent) action("x")).ContinueWith(Function(antecendent) negate(7)).Wait()
    End Sub
End Module

Comentarios

El devuelto Task<TResult> no se programará para su ejecución hasta que se haya completado la tarea actual, independientemente de si se completa debido a que se ha completado correctamente, se produce un error debido a una excepción no controlada o se cierra temprano debido a la cancelación.

Se aplica a

ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)

Crea una continuación que se ejecuta de forma asincrónica cuando el elemento Task de destino se completa y devuelve un valor. La continuación usa un programador especificado.

public:
generic <typename TResult>
 System::Threading::Tasks::Task<TResult> ^ ContinueWith(Func<System::Threading::Tasks::Task ^, TResult> ^ continuationFunction, System::Threading::Tasks::TaskScheduler ^ scheduler);
public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.Tasks.TaskScheduler scheduler);
member this.ContinueWith : Func<System.Threading.Tasks.Task, 'Result> * System.Threading.Tasks.TaskScheduler -> System.Threading.Tasks.Task<'Result>
Public Function ContinueWith(Of TResult) (continuationFunction As Func(Of Task, TResult), scheduler As TaskScheduler) As Task(Of TResult)

Parámetros de tipo

TResult

Tipo de resultado generado por la continuación.

Parámetros

continuationFunction
Func<Task,TResult>

Función que se va a ejecutar cuando se complete el objeto Task. Cuando se ejecute, al delegado se le pasará la tarea completada como un argumento.

scheduler
TaskScheduler

Objeto TaskScheduler que se va a asociar a la tarea de continuación y se va a usar para su ejecución.

Devoluciones

Task<TResult>

Nuevo objeto Task<TResult> de continuación.

Excepciones

Se ha eliminado Task.

El argumento continuationFunction es null.

O bien El argumento scheduler es null.

Comentarios

El devuelto Task<TResult> no se programará para su ejecución hasta que se haya completado la tarea actual, independientemente de si se completa debido a la ejecución correcta, a errores debido a una excepción no controlada o a la salida anticipada debido a que se canceló.

Se aplica a