CancellationTokenSource Classe

Definição

Namespace:

System.Threading

Assembly:

System.Runtime.dll

Origem:

CancellationTokenSource.cs

Sinaliza para um CancellationToken que ele deve ser cancelado.

C#

public class CancellationTokenSource : IDisposable

Herança

Object

CancellationTokenSource

Implementações

IDisposable

Exemplos

O exemplo a seguir usa um gerador de número aleatório para emular um aplicativo de coleta de dados que lê 10 valores integrais de onze instrumentos diferentes. Um valor zero indica que a medida falhou em um instrumento, caso em que a operação deve ser cancelada e nenhuma média geral deve ser computada.

Para lidar com o possível cancelamento da operação, o exemplo cria uma instância de um objeto CancellationTokenSource que gera um token de cancelamento que é passado para um objeto TaskFactory. O objeto TaskFactory, por sua vez, passa o token de cancelamento para cada uma das tarefas responsáveis por coletar leituras para um determinado instrumento. O método TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) é chamado para garantir que a média seja computada somente depois que todas as leituras tiverem sido coletadas com êxito. Se uma tarefa não tiver sido concluída porque foi cancelada, a chamada para o método TaskFactory.ContinueWhenAll gerará uma exceção.

C#

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Define the cancellation token.
      CancellationTokenSource source = new CancellationTokenSource();
      CancellationToken token = source.Token;

      Random rnd = new Random();
      Object lockObj = new Object();
      
      List<Task<int[]>> tasks = new List<Task<int[]>>();
      TaskFactory factory = new TaskFactory(token);
      for (int taskCtr = 0; taskCtr <= 10; taskCtr++) {
         int iteration = taskCtr + 1;
         tasks.Add(factory.StartNew( () => {
           int value;
           int[] values = new int[10];
           for (int ctr = 1; ctr <= 10; ctr++) {
              lock (lockObj) {
                 value = rnd.Next(0,101);
              }
              if (value == 0) { 
                 source.Cancel();
                 Console.WriteLine("Cancelling at task {0}", iteration);
                 break;
              }   
              values[ctr-1] = value; 
           }
           return values;
        }, token));   
      }
      try {
         Task<double> fTask = factory.ContinueWhenAll(tasks.ToArray(), 
         (results) => {
            Console.WriteLine("Calculating overall mean...");
            long sum = 0;
            int n = 0; 
            foreach (var t in results) {
               foreach (var r in t.Result) {
                  sum += r;
                  n++;
               }
            }
            return sum/(double) n;
         } , token);
         Console.WriteLine("The mean is {0}.", fTask.Result);
      }   
      catch (AggregateException ae) {
         foreach (Exception e in ae.InnerExceptions) {
            if (e is TaskCanceledException)
               Console.WriteLine("Unable to compute mean: {0}", 
                  ((TaskCanceledException) e).Message);
            else
               Console.WriteLine("Exception: " + e.GetType().Name);
         }
      }
      finally {
         source.Dispose();
      }
   }
}
// Repeated execution of the example produces output like the following:
//       Cancelling at task 5
//       Unable to compute mean: A task was canceled.
//       
//       Cancelling at task 10
//       Unable to compute mean: A task was canceled.
//       
//       Calculating overall mean...
//       The mean is 5.29545454545455.
//       
//       Cancelling at task 4
//       Unable to compute mean: A task was canceled.
//       
//       Cancelling at task 5
//       Unable to compute mean: A task was canceled.
//       
//       Cancelling at task 6
//       Unable to compute mean: A task was canceled.
//       
//       Calculating overall mean...
//       The mean is 4.97363636363636.
//       
//       Cancelling at task 4
//       Unable to compute mean: A task was canceled.
//       
//       Cancelling at task 5
//       Unable to compute mean: A task was canceled.
//       
//       Cancelling at task 4
//       Unable to compute mean: A task was canceled.
//       
//       Calculating overall mean...
//       The mean is 4.86545454545455.

Comentários

A partir do .NET Framework 4, o .NET Framework usa um modelo unificado para cancelamento cooperativo de operações síncronas assíncronas ou de execução longa que envolvem dois objetos:

• Um objeto CancellationTokenSource, que fornece um token de cancelamento por meio de sua propriedade Token e envia uma mensagem de cancelamento chamando seu método Cancel ou CancelAfter.

• Um objeto CancellationToken, que indica se o cancelamento é solicitado.

O padrão geral para implementar o modelo de cancelamento cooperativo é:

• Instancie um objeto CancellationTokenSource, que gerencia e envia uma notificação de cancelamento para os tokens de cancelamento individuais.

• Passe o token retornado pela propriedade CancellationTokenSource.Token para cada tarefa ou thread que escuta o cancelamento.

• Chame o método CancellationToken.IsCancellationRequested de operações que recebem o token de cancelamento. Forneça um mecanismo para cada tarefa ou thread responder a uma solicitação de cancelamento. Se você optar por cancelar uma operação e exatamente como fazer isso, depende da lógica do aplicativo.

• Chame o método CancellationTokenSource.Cancel para fornecer notificação de cancelamento. Isso define a propriedade CancellationToken.IsCancellationRequested em cada cópia do token de cancelamento como true.

• Chame o método Dispose quando terminar de usar o objeto CancellationTokenSource.

Para obter mais informações, consulte Cancelamento em Threads Gerenciados.

Importante

Esse tipo implementa a interface IDisposable. Quando terminar de usar uma instância do tipo, você deverá descartá-la direta ou indiretamente. Para descartar o tipo diretamente, chame seu método Dispose em um bloco de try/finally. Para descartá-lo indiretamente, use um constructo de linguagem como using (em C#) ou Using (no Visual Basic). Para obter mais informações, consulte a seção "Usando um objeto que implementa idisposable" no tópico da interface IDisposable.

Construtores

CancellationTokenSource()	Inicializa uma nova instância da classe CancellationTokenSource.
CancellationTokenSource(Int32)	Inicializa uma nova instância da classe CancellationTokenSource que será cancelada após o atraso especificado em milissegundos.
CancellationTokenSource(TimeSpan)	Inicializa uma nova instância da classe CancellationTokenSource que será cancelada após o período de tempo especificado.
CancellationTokenSource(TimeSpan, TimeProvider)	Inicializa uma nova instância da classe CancellationTokenSource que será cancelada após o TimeSpanespecificado.

Propriedades

IsCancellationRequested	Obtém se o cancelamento foi solicitado para este CancellationTokenSource.
Token	Obtém o CancellationToken associado a esse CancellationTokenSource.

Métodos

Cancel()	Comunica uma solicitação de cancelamento.
Cancel(Boolean)	Comunica uma solicitação de cancelamento e especifica se os retornos de chamada restantes e as operações canceláveis devem ser processados se ocorrer uma exceção.
CancelAfter(Int32)	Agenda uma operação de cancelamento neste CancellationTokenSource após o número especificado de milissegundos.
CancelAfter(TimeSpan)	Agenda uma operação de cancelamento neste CancellationTokenSource após o período de tempo especificado.
CancelAsync()	Comunica uma solicitação de cancelamento de forma assíncrona.
CreateLinkedTokenSource(CancellationToken)	Cria um CancellationTokenSource que estará no estado cancelado quando o token fornecido estiver no estado cancelado.
CreateLinkedTokenSource(CancellationToken, CancellationToken)	Cria um CancellationTokenSource que estará no estado cancelado quando qualquer um dos tokens de origem estiver no estado cancelado.
CreateLinkedTokenSource(CancellationToken[])	Cria um CancellationTokenSource que estará no estado cancelado quando qualquer um dos tokens de origem na matriz especificada estiver no estado cancelado.
Dispose()	Libera todos os recursos usados pela instância atual da classe CancellationTokenSource.
Dispose(Boolean)	Libera os recursos não gerenciados usados pela classe CancellationTokenSource e, opcionalmente, libera os recursos gerenciados.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Objectatual. (Herdado de Object)
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
TryReset()	Tenta redefinir o CancellationTokenSource a ser usado para uma operação não relacionada.

Aplica-se a

Acesso thread-safe

Todos os membros públicos e protegidos de CancellationTokenSource são thread-safe e podem ser usados simultaneamente de vários threads, com exceção de Dispose(), que só devem ser usados quando todas as outras operações no objeto CancellationTokenSource tiverem sido concluídas.

Confira também

• de cancelamento de
• de cancelamento de tarefa