Task.ContinueWith Método

Definição

Namespace:

System.Threading.Tasks

Assembly:

System.Runtime.dll

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>)	Criará uma continuação executada de forma assíncrona quando o Task de destino for concluído.
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,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>, 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, 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, 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, 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,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,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,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<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,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(Action<Task,Object>, Object, CancellationToken, TaskContinuationOptions, TaskScheduler)

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.

C#

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

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.

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

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.

C#

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

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.

C#

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

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.

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

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.

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.Tasks.TaskScheduler scheduler);

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.

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

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.

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

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.

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

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.

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state, System.Threading.CancellationToken cancellationToken);

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

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.

ContinueWith(Action<Task>)

Origem:

Task.cs

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

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction);

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.

C#

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

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

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.

ContinueWith(Action<Task>, TaskContinuationOptions)

Origem:

Task.cs

Cria uma continuação que é executada quando a tarefa de destino é concluída conforme o TaskContinuationOptions especificado.

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

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.)

C#

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

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.

ContinueWith(Action<Task>, CancellationToken)

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.

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.CancellationToken cancellationToken);

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

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.

ContinueWith(Action<Task,Object>, Object)

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.

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task,object?> continuationAction, object? state);

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

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.

ContinueWith(Action<Task>, TaskScheduler)

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.

C#

public System.Threading.Tasks.Task ContinueWith (Action<System.Threading.Tasks.Task> continuationAction, System.Threading.Tasks.TaskScheduler scheduler);

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

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.

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

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.

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.Tasks.TaskScheduler scheduler);

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.

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

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.

C#

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

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.

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

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.

C#

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

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:

C#

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

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.

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

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.

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.CancellationToken cancellationToken);

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

O retornado Task<TResult> não será agendado para execução até que a tarefa atual seja concluída, seja 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.

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

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.

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

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.

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

Origem:

Task.cs

Cria uma continuação que executa de acordo com as opções de continuação especificadas e retorna um valor.

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions);

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

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.

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

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.

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.Tasks.TaskScheduler scheduler);

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

O retornado Task<TResult> não será agendado para execução até que a tarefa atual seja concluída, seja 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.

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

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.

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction, System.Threading.CancellationToken cancellationToken);

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

O retornado Task<TResult> não será agendado para execução até que a tarefa atual seja concluída, seja 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.

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

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.

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,object?,TResult> continuationFunction, object? state);

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

O retornado Task<TResult> não será agendado para execução até que a tarefa atual seja concluída, seja 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.

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

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.

C#

public System.Threading.Tasks.Task<TResult> ContinueWith<TResult> (Func<System.Threading.Tasks.Task,TResult> continuationFunction);

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:

C#

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

Comentários

O retornado Task<TResult> não será agendado para execução até que a tarefa atual seja concluída, seja 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.