Task.ContinueWith Método

Referência

Definição

Namespace:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído.

Sobrecargas

ContinueWith(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Cria uma continuação que recebe informações de estado e um token de cancelamento fornecidos pelo chamador e que será executada quando a Task de destino for concluída. A continuação é executada com base em um conjunto de condições especificadas e usa um agendador especificado.
ContinueWith(Action<Task>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Cria uma continuação que é executada quando a tarefa de destino compete conforme o TaskContinuationOptions especificado. A continuação recebe um token de cancelamento e usa um agendador especificado.
ContinueWith(Action<Task,Object>, Object, TaskScheduler)	Cria uma continuação que recebe informações de estado fornecidas pelo chamador e executa de forma assíncrona quando o destino Task for concluído. A continuação usa um agendador especificado.
ContinueWith(Action<Task,Object>, Object, TaskContinuationOptions)	Cria uma continuação que recebe informações de estado fornecidas pelo chamador e executa quando Task de destino for concluída. A continuação é executada com base em um conjunto de condições especificadas.
ContinueWith(Action<Task,Object>, Object, CancellationToken)	Cria uma continuação que recebe informações de estado e um token de cancelamento fornecidos pelo chamador e que será executada de maneira assíncrona quando a Task de destino for concluída.
ContinueWith(Action<Task,Object>, Object)	Cria uma continuação que recebe informações de estado fornecidas pelo chamador e executa quando Task de destino for concluída.
ContinueWith(Action<Task>, TaskContinuationOptions)	Cria uma continuação que é executada quando a tarefa de destino é concluída conforme o TaskContinuationOptions especificado.
ContinueWith(Action<Task>, CancellationToken)	Cria uma continuação que recebe um token de cancelamento e é executada de forma assíncrona quando o Task de destino é concluído.
ContinueWith(Action<Task>)	Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído.
ContinueWith(Action<Task>, TaskScheduler)	Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído. A continuação usa um agendador especificado.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskContinuationOptions)	Cria uma continuação que é executada com base nas opções de continuação de tarefas especificadas quando o Task de destino é concluído. A continuação recebe informações de estado fornecidas pelo chamador.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)	Cria uma continuação executada com base nas opções de continuação de tarefas especificadas quando o Task de destino for concluído e retornar um valor. A continuação recebe informações de estado fornecidas pelo chamador e um token de cancelamento e usa o agendador especificado.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)	Cria uma continuação que executa de acordo com as opções de continuação especificadas e retorna um valor. Um token de cancelamento é passado à continuação e ela usa um agendador especificado.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, TaskScheduler)	Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído. A continuação recebe informações de estado fornecidas pelo chamador e usa um agendador especificado.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object, CancellationToken)	Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído e retornar um valor. A continuação recebe informações de estado fornecido pelo chamador e um token de cancelamento.
ContinueWith<TResult>(Func<Task,TResult>, CancellationToken)	Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído e retornar um valor. A continuação recebe um token de cancelamento.
ContinueWith<TResult>(Func<Task,TResult>, TaskContinuationOptions)	Cria uma continuação que executa de acordo com as opções de continuação especificadas e retorna um valor.
ContinueWith<TResult>(Func<Task,Object,TResult>, Object)	Cria uma continuação que recebe informações de estado fornecidas pelo chamador e que é executada de forma assíncrona quando o Task de destino é concluído e retorna um valor.
ContinueWith<TResult>(Func<Task,TResult>)	Criará uma continuação executada de forma assíncrona quando o Task<TResult> de destino for concluído e retornar um valor.
ContinueWith<TResult>(Func<Task,TResult>, TaskScheduler)	Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído e retornar um valor. A continuação usa um agendador especificado.

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma continuação que recebe informações de estado e um token de cancelamento fornecidos pelo chamador e que será executada quando a Task de destino for concluída. A continuação é executada com base em um conjunto de condições especificadas e usa um agendador 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>

Uma ação a ser executada quando o Task for concluído. Quando executada, a tarefa concluída e o objeto de estado fornecido pelo chamador serão passados como argumentos ao delegado.

state: Object

Um objeto que representa os dados a serem usados pela ação de continuação.

cancellationToken: CancellationToken

O CancellationToken que será atribuído à nova tarefa de continuação.

continuationOptions: TaskContinuationOptions

Opções para quando a continuação é agendada e como ela se comporta. Isso inclui critérios como OnlyOnCanceled, além de opções de execução como ExecuteSynchronously.

scheduler: TaskScheduler

O TaskScheduler a ser associado à tarefa de continuação e a ser usado para sua execução.

Retornos

Task

Um novo Task de continuação.

Exceções

ArgumentNullException

O argumento scheduler é null.

ArgumentOutOfRangeException

O argumento continuationOptions especifica um valor inválido para TaskContinuationOptions.

ObjectDisposedException

O CancellationToken fornecido já foi descartado.

Comentários

O retornado Task não será agendado para execução até que a tarefa atual seja concluída. Se os critérios especificados por meio do continuationOptions parâmetro não forem atendidos, a tarefa de continuação será cancelada em vez de agendada.

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma continuação que é executada quando a tarefa de destino compete conforme o TaskContinuationOptions especificado. A continuação recebe um token de cancelamento e usa um agendador 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>

Uma ação a ser executada de acordo com o continuationOptions especificado. Quando executado, o delegado passará a tarefa concluída como um argumento.

cancellationToken: CancellationToken

O CancellationToken que será atribuído à nova tarefa de continuação.

continuationOptions: TaskContinuationOptions

Opções para quando a continuação é agendada e como ela se comporta. Isso inclui critérios como OnlyOnCanceled, além de opções de execução como ExecuteSynchronously.

scheduler: TaskScheduler

O TaskScheduler a ser associado à tarefa de continuação e a ser usado para sua execução.

Retornos

Task

Um novo Task de continuação.

Exceções

ObjectDisposedException

O CancellationTokenSource que criou o token já foi descartado.

ArgumentNullException

O argumento continuationAction é nulo.

- ou -

O argumento scheduler é nulo.

ArgumentOutOfRangeException

O argumento continuationOptions especifica um valor inválido para TaskContinuationOptions.

Exemplos

Veja a seguir um exemplo de como usar ContinueWith para executar o trabalho em segundo plano e nos threads da interface do usuário.

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

Comentários

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma continuação que recebe informações de estado fornecidas pelo chamador e executa de forma assíncrona quando o destino Task for concluído. A continuação usa um agendador 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>

Uma ação a ser executada quando o Task for concluído. Quando executada, a tarefa concluída e o objeto de estado fornecido pelo chamador serão passados como argumentos ao delegado.

state: Object

Um objeto que representa os dados a serem usados pela ação de continuação.

scheduler: TaskScheduler

O TaskScheduler a ser associado à tarefa de continuação e a ser usado para sua execução.

Retornos

Task

Um novo Task de continuação.

Exceções

ArgumentNullException

O argumento scheduler é null.

Comentários

O retornado Task não será agendado para execução até que a tarefa atual seja concluída, seja ela concluída devido à execução da conclusão com êxito, falha devido a uma exceção sem tratamento ou saída antecipada devido ao cancelamento.

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma continuação que recebe informações de estado fornecidas pelo chamador e executa quando Task de destino for concluída. A continuação é executada com base em um conjunto de condições 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>

Uma ação a ser executada quando o Task for concluído. Quando executada, a tarefa concluída e o objeto de estado fornecido pelo chamador serão passados como argumentos ao delegado.

state: Object

Um objeto que representa os dados a serem usados pela ação de continuação.

continuationOptions: TaskContinuationOptions

Opções para quando a continuação é agendada e como ela se comporta. Isso inclui critérios como OnlyOnCanceled, além de opções de execução como ExecuteSynchronously.

Retornos

Task

Um novo Task de continuação.

Exceções

ArgumentNullException

O argumento continuationAction é null.

ArgumentOutOfRangeException

O argumento continuationOptions especifica um valor inválido para TaskContinuationOptions.

Comentários

O retornado Task não será agendado para execução até que a tarefa atual seja concluída. Se os critérios de continuação especificados por meio do continuationOptions parâmetro não forem atendidos, a tarefa de continuação será cancelada em vez de agendada.

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma continuação que recebe informações de estado e um token de cancelamento fornecidos pelo chamador e que será executada de maneira assíncrona quando a Task de destino for concluída.

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>

Uma ação a ser executada quando o Task for concluído. Quando executada, a tarefa concluída e o objeto de estado fornecido pelo chamador serão passados como argumentos ao delegado.

state: Object

Um objeto que representa os dados a serem usados pela ação de continuação.

cancellationToken: CancellationToken

O CancellationToken que será atribuído à nova tarefa de continuação.

Retornos

Task

Um novo Task de continuação.

Exceções

ArgumentNullException

O argumento continuationAction é null.

ObjectDisposedException

O CancellationToken fornecido já foi descartado.

Comentários

Aplica-se a

ContinueWith(Action<Task,Object>, Object)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma continuação que recebe informações de estado fornecidas pelo chamador e executa quando Task de destino for concluída.

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>

Uma ação a ser executada quando a tarefa for concluída. Quando executado, o delegado recebe a tarefa concluída e um objeto de estado fornecido pelo chamador como argumentos.

state: Object

Um objeto que representa os dados a serem usados pela ação de continuação.

Retornos

Task

Uma nova tarefa de continuação.

Exceções

ArgumentNullException

O argumento continuationAction é null.

Comentários

Aplica-se a

ContinueWith(Action<Task>, TaskContinuationOptions)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma continuação que é executada quando a tarefa de destino é concluída conforme o 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>

Uma ação a ser executada de acordo com o continuationOptions especificado. Quando executado, o delegado passará a tarefa concluída como um argumento.

continuationOptions: TaskContinuationOptions

Opções para quando a continuação é agendada e como ela se comporta. Isso inclui critérios como OnlyOnCanceled, além de opções de execução como ExecuteSynchronously.

Retornos

Task

Um novo Task de continuação.

Exceções

ArgumentNullException

O argumento continuationAction é nulo.

ArgumentOutOfRangeException

O argumento continuationOptions especifica um valor inválido para TaskContinuationOptions.

Exemplos

O exemplo a seguir demonstra como usar TaskContinuationOptions para especificar que uma tarefa de continuação deve ser executada de forma síncrona quando a tarefa antecessora for concluída. (Se a tarefa especificada já tiver sido concluída até o momento ContinueWith em que for chamada, a continuação síncrona será executada no thread chamando ContinueWith.)

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

Comentários

Aplica-se a

ContinueWith(Action<Task>, CancellationToken)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma continuação que recebe um token de cancelamento e é executada de forma assíncrona quando o Task de destino é concluído.

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>

Uma ação a ser executada quando o Task for concluído. Quando executado, o delegado passará a tarefa concluída como um argumento.

cancellationToken: CancellationToken

O CancellationToken que será atribuído à nova tarefa de continuação.

Retornos

Task

Um novo Task de continuação.

Exceções

ObjectDisposedException

O CancellationTokenSource que criou o token já foi descartado.

ArgumentNullException

O argumento continuationAction é nulo.

Comentários

Aplica-se a

ContinueWith(Action<Task>)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído.

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>

Uma ação a ser executada quando o Task for concluído. Quando executado, o delegado passará a tarefa concluída como um argumento.

Retornos

Task

Um novo Task de continuação.

Exceções

ArgumentNullException

O argumento continuationAction é null.

Exemplos

O exemplo a seguir define uma tarefa que preenche uma matriz com 100 valores aleatórios de data e hora. Ele usa o ContinueWith(Action<Task>) método para selecionar os valores de data mais antigos e mais recentes depois que a matriz é totalmente preenchida.

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

open System
open System.Threading.Tasks

let firstTask =
    Task.Factory.StartNew(fun () ->
        let rnd = Random()
        let dates = Array.zeroCreate 100
        let buffer = Array.zeroCreate 8
        let mutable i = dates.GetLowerBound 0

        while i <= dates.GetUpperBound 0 do
            rnd.NextBytes buffer
            let ticks = BitConverter.ToInt64(buffer, 0)

            if ticks > DateTime.MinValue.Ticks && ticks < DateTime.MaxValue.Ticks then
                dates[i] <- DateTime ticks
                i <- i + 1

        dates)

let continuationTask =
    firstTask.ContinueWith(
        Action<Task<DateTime[]>>(fun antecedent ->
            let dates: DateTime[] = antecedent.Result
            let mutable earliest = dates[0]
            let mutable latest = earliest

            for i = dates.GetLowerBound 0 + 1 to dates.GetUpperBound 0 do
                if dates.[i] < earliest then
                    earliest <- dates.[i]

                if dates.[i] > latest then
                    latest <- dates.[i]

            printfn $"Earliest date: {earliest}"
            printfn $"Latest date: {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

Como um aplicativo de console pode terminar antes da execução da tarefa de continuação, o Wait() método é chamado para garantir que a continuação termine de ser executada antes do fim do exemplo.

Para obter um exemplo adicional, consulte Encadeamento de tarefas usando tarefas de continuação.

Comentários

Aplica-se a

ContinueWith(Action<Task>, TaskScheduler)

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído. A continuação usa um agendador 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>

Uma ação a ser executada quando o Task for concluído. Quando executado, o delegado passará a tarefa concluída como um argumento.

scheduler: TaskScheduler

O TaskScheduler a ser associado à tarefa de continuação e a ser usado para sua execução.

Retornos

Task

Um novo Task de continuação.

Exceções

ObjectDisposedException

O Task foi descartado.

ArgumentNullException

O argumento continuationAction é null.

- ou -

O argumento scheduler é nulo.

Comentários

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma continuação que é executada com base nas opções de continuação de tarefas especificadas quando o Task de destino é concluído. A continuação recebe informações de estado fornecidas pelo chamador.

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

O tipo do resultado produzido pela continuação.

Parâmetros

continuationFunction: Func<Task,Object,TResult>

Uma função a ser executada quando o Task for concluído. Quando executada, a tarefa concluída e o objeto de estado fornecido pelo chamador serão passados como argumentos ao delegado.

state: Object

Um objeto que representa os dados a serem usados pela função de continuação.

continuationOptions: TaskContinuationOptions

Opções para quando a continuação é agendada e como ela se comporta. Isso inclui critérios como OnlyOnCanceled, além de opções de execução como ExecuteSynchronously.

Retornos

Task<TResult>

Um novo Task<TResult> de continuação.

Exceções

ArgumentNullException

O argumento continuationFunction é null.

ArgumentOutOfRangeException

O argumento continuationOptions especifica um valor inválido para TaskContinuationOptions.

Comentários

O retornado Task<TResult> não será agendado para execução até que a tarefa atual seja concluída. Se os critérios de continuação especificados por meio do continuationOptions parâmetro não forem atendidos, a tarefa de continuação será cancelada em vez de agendada.

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma continuação executada com base nas opções de continuação de tarefas especificadas quando o Task de destino for concluído e retornar um valor. A continuação recebe informações de estado fornecidas pelo chamador e um token de cancelamento e usa o agendador 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

O tipo do resultado produzido pela continuação.

Parâmetros

continuationFunction: Func<Task,Object,TResult>

Uma função a ser executada quando o Task for concluído. Quando executada, a tarefa concluída e o objeto de estado fornecido pelo chamador serão passados como argumentos ao delegado.

state: Object

Um objeto que representa os dados a serem usados pela função de continuação.

cancellationToken: CancellationToken

O CancellationToken que será atribuído à nova tarefa de continuação.

continuationOptions: TaskContinuationOptions

Opções para quando a continuação é agendada e como ela se comporta. Isso inclui critérios como OnlyOnCanceled, além de opções de execução como ExecuteSynchronously.

scheduler: TaskScheduler

O TaskScheduler a ser associado à tarefa de continuação e a ser usado para sua execução.

Retornos

Task<TResult>

Um novo Task<TResult> de continuação.

Exceções

ArgumentNullException

O argumento scheduler é null.

ArgumentOutOfRangeException

O argumento continuationOptions especifica um valor inválido para TaskContinuationOptions.

ObjectDisposedException

O CancellationToken fornecido já foi descartado.

Comentários

O retornado Task<TResult> não será agendado para execução até que a tarefa atual seja concluída. Se os critérios especificados por meio do continuationOptions parâmetro não forem atendidos, a tarefa de continuação será cancelada em vez de agendada.

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma continuação que executa de acordo com as opções de continuação especificadas e retorna um valor. Um token de cancelamento é passado à continuação e ela usa um agendador 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

O tipo do resultado produzido pela continuação.

Parâmetros

continuationFunction: Func<Task,TResult>

Uma função a ser executada de acordo com o continuationOptions. especificado. Quando executado, o delegado passará a tarefa concluída como um argumento.

cancellationToken: CancellationToken

O CancellationToken que será atribuído à nova tarefa de continuação.

continuationOptions: TaskContinuationOptions

Opções para quando a continuação é agendada e como ela se comporta. Isso inclui critérios como OnlyOnCanceled, além de opções de execução como ExecuteSynchronously.

scheduler: TaskScheduler

O TaskScheduler a ser associado à tarefa de continuação e a ser usado para sua execução.

Retornos

Task<TResult>

Um novo Task<TResult> de continuação.

Exceções

ObjectDisposedException

O Task foi descartado.

- ou -

O CancellationTokenSource que criou o token já foi descartado.

ArgumentNullException

O argumento continuationFunction é nulo.

- ou -

O argumento scheduler é nulo.

ArgumentOutOfRangeException

O argumento continuationOptions especifica um valor inválido para TaskContinuationOptions.

Exemplos

O exemplo a seguir mostra como usar o método ContinueWith com opções de continuação:

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();
    }
}

open System
open System.Threading
open System.Threading.Tasks

// 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
let success =
    fun () ->
        printfn $"Task={Task.CurrentId}, Thread={Thread.CurrentThread.ManagedThreadId}: Begin successful transaction"

let failure =
    fun () ->

        printfn
            $"Task={Task.CurrentId}, Thread={Thread.CurrentThread.ManagedThreadId}: Begin transaction and encounter an error"

        raise (InvalidOperationException "SIMULATED EXCEPTION")

let commit =
    fun antecendent ->
        printfn $"Task={Task.CurrentId}, Thread={Thread.CurrentThread.ManagedThreadId}: Commit transaction"

let rollback =
    fun (antecendent: Task) ->

        // "Observe" your antecedent's exception so as to avoid an exception
        // being thrown on the finalizer thread
        let unused = antecendent.Exception

        printfn $"Task={Task.CurrentId}, Thread={Thread.CurrentThread.ManagedThreadId}: Rollback transaction"

// Successful transaction - Begin + Commit
printfn "Demonstrating a successful transaction"

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

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

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

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

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

// Failed transaction - Begin + exception + Rollback
printfn "\nDemonstrating a failed transaction"

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

// The following task gets scheduled only if tran2 completes successfully
let commitTran2 =
    tran2.ContinueWith(Action<Task> commit, TaskContinuationOptions.OnlyOnRanToCompletion)

// The following task gets scheduled only if tran2 DOES NOT complete successfully
let rollbackTran2 =
    tran2.ContinueWith(Action<Task> 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

Comentários

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído. A continuação recebe informações de estado fornecidas pelo chamador e usa um agendador 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

O tipo do resultado produzido pela continuação.

Parâmetros

continuationFunction: Func<Task,Object,TResult>

Uma função a ser executada quando o Task for concluído. Quando executada, a tarefa concluída e o objeto de estado fornecido pelo chamador serão passados como argumentos ao delegado.

state: Object

Um objeto que representa os dados a serem usados pela função de continuação.

scheduler: TaskScheduler

O TaskScheduler a ser associado à tarefa de continuação e a ser usado para sua execução.

Retornos

Task<TResult>

Um novo Task<TResult> de continuação.

Exceções

ArgumentNullException

O argumento scheduler é null.

Comentários

O retornado Task<TResult> não será agendado para execução até que a tarefa atual seja concluída, seja ela concluída devido à execução da conclusão com êxito, falha devido a uma exceção sem tratamento ou saída antecipada devido ao cancelamento.

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído e retornar um valor. A continuação recebe informações de estado fornecido pelo chamador e um token de cancelamento.

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

O tipo do resultado produzido pela continuação.

Parâmetros

continuationFunction: Func<Task,Object,TResult>

Uma função a ser executada quando o Task for concluído. Quando executada, a tarefa concluída e o objeto de estado fornecido pelo chamador serão passados como argumentos ao delegado.

state: Object

Um objeto que representa os dados a serem usados pela função de continuação.

cancellationToken: CancellationToken

O CancellationToken que será atribuído à nova tarefa de continuação.

Retornos

Task<TResult>

Um novo Task<TResult> de continuação.

Exceções

ArgumentNullException

O argumento continuationFunction é null.

ObjectDisposedException

O CancellationToken fornecido já foi descartado.

Comentários

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído e retornar um valor. A continuação recebe um token de cancelamento.

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

O tipo do resultado produzido pela continuação.

Parâmetros

continuationFunction: Func<Task,TResult>

Uma função a ser executada quando o Task for concluído. Quando executado, o delegado passará a tarefa concluída como um argumento.

cancellationToken: CancellationToken

O CancellationToken que será atribuído à nova tarefa de continuação.

Retornos

Task<TResult>

Um novo Task<TResult> de continuação.

Exceções

ObjectDisposedException

O Task foi descartado.

- ou -

O CancellationTokenSource que criou o token já foi descartado.

ArgumentNullException

O argumento continuationFunction é nulo.

Comentários

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma continuação que executa de acordo com as opções de continuação especificadas e retorna um 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

O tipo do resultado produzido pela continuação.

Parâmetros

continuationFunction: Func<Task,TResult>

Uma função a ser executada de acordo com a condição especificada em continuationOptions. Quando executado, o delegado passará a tarefa concluída como um argumento.

continuationOptions: TaskContinuationOptions

Opções para quando a continuação é agendada e como ela se comporta. Isso inclui critérios como OnlyOnCanceled, além de opções de execução como ExecuteSynchronously.

Retornos

Task<TResult>

Um novo Task<TResult> de continuação.

Exceções

ObjectDisposedException

O Task foi descartado.

ArgumentNullException

O argumento continuationFunction é nulo.

ArgumentOutOfRangeException

O argumento continuationOptions especifica um valor inválido para TaskContinuationOptions.

Comentários

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Cria uma continuação que recebe informações de estado fornecidas pelo chamador e que é executada de forma assíncrona quando o Task de destino é concluído e retorna um 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

O tipo do resultado produzido pela continuação.

Parâmetros

continuationFunction: Func<Task,Object,TResult>

Uma função a ser executada quando o Task for concluído. Quando executada, a tarefa concluída e o objeto de estado fornecido pelo chamador serão passados como argumentos ao delegado.

state: Object

Um objeto que representa os dados a serem usados pela função de continuação.

Retornos

Task<TResult>

Um novo Task<TResult> de continuação.

Exceções

ArgumentNullException

O argumento continuationFunction é null.

Comentários

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Criará uma continuação executada de forma assíncrona quando o Task<TResult> de destino for concluído e retornar um 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

O tipo do resultado produzido pela continuação.

Parâmetros

continuationFunction: Func<Task,TResult>

Uma função a ser executada quando o Task<TResult> for concluído. Quando executado, o delegado passará a tarefa concluída como um argumento.

Retornos

Task<TResult>

Uma nova tarefa de continuação.

Exceções

ObjectDisposedException

O Task foi descartado.

ArgumentNullException

O argumento continuationFunction é nulo.

Exemplos

O exemplo a seguir mostra como usar o 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();
    }
}

open System
open System.Threading
open System.Threading.Tasks

// 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
let action =
    fun str -> printfn $"Task={Task.CurrentId}, str=%s{str}, Thread={Thread.CurrentThread.ManagedThreadId}"

// Creating a sequence of action tasks (that return no result).
printfn "Creating a sequence of action tasks (that return no result)"

Task
    .Factory
    .StartNew(fun () -> action "alpha")
    .ContinueWith(fun antecendent -> action "beta") // Antecedent data is ignored
    .ContinueWith(fun antecendent -> action "gamma")
    .Wait()

let negate =
    fun n ->
        printfn $"Task={Task.CurrentId}, n={n}, -n={2 - n}, Thread={Thread.CurrentThread.ManagedThreadId}"
        -n

// Creating a sequence of function tasks where each continuation uses the result from its antecendent
printfn "\nCreating a sequence of function tasks where each continuation uses the result from its antecendent"

Task<int>
    .Factory.StartNew(fun () -> negate 5)
    .ContinueWith(Func<Task<int>, int>(fun antecedent -> negate antecedent.Result)) // Antecedent result feeds into continuation
    .ContinueWith(Func<Task<int>, int>(fun antecedent -> negate antecedent.Result))
    .Wait()

// Creating a sequence of tasks where you can mix and match the types
printfn "\nCreating a sequence of tasks where you can mix and match the types"

Task<int>
    .Factory.StartNew(fun () -> negate 6)
    .ContinueWith(Action<Task>(fun antecendent -> action "x"))
    .ContinueWith(fun 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

Comentários

Aplica-se a

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

Origem:: Task.cs

Origem:: Task.cs

Origem:: Task.cs

Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído e retornar um valor. A continuação usa um agendador 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

O tipo do resultado produzido pela continuação.

Parâmetros

continuationFunction: Func<Task,TResult>

Uma função a ser executada quando o Task for concluído. Quando executado, o delegado passará a tarefa concluída como um argumento.

scheduler: TaskScheduler

O TaskScheduler a ser associado à tarefa de continuação e a ser usado para sua execução.

Retornos

Task<TResult>

Um novo Task<TResult> de continuação.

Exceções

ObjectDisposedException

O Task foi descartado.

ArgumentNullException

O argumento continuationFunction é nulo.

- ou -

O argumento scheduler é nulo.

Comentários

Aplica-se a