CancellationToken Estrutura

Definição

Namespace:

System.Threading

Assembly:

System.Threading.Tasks.dll

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Propaga a notificação de que as operações devem ser canceladas.

C#

public struct CancellationToken

C#

public readonly struct CancellationToken

C#

public readonly struct CancellationToken : IEquatable<System.Threading.CancellationToken>

C#

[System.Runtime.InteropServices.ComVisible(false)]
public struct CancellationToken

Herança

Object

ValueType

CancellationToken

Atributos

ComVisibleAttribute

Implementações

IEquatable<CancellationToken>

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, nesse caso, 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 CancellationTokenSource objeto que gera um token de cancelamento que é passado para um TaskFactory objeto. Por sua vez, o TaskFactory objeto passa o token de cancelamento para cada uma das tarefas responsáveis por coletar leituras para um determinado instrumento. O TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) método é chamado para garantir que a média seja calculada somente depois que todas as leituras tiverem sido coletadas com êxito. Se uma tarefa não tiver sido concluída porque foi cancelada, o TaskFactory.ContinueWhenAll método 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

Um CancellationToken permite o cancelamento cooperativo entre threads, itens de trabalho do pool de threads ou Task objetos. Você cria um token de cancelamento instanciando um CancellationTokenSource objeto, que gerencia tokens de cancelamento recuperados de sua CancellationTokenSource.Token propriedade. Em seguida, você passa o token de cancelamento para qualquer número de threads, tarefas ou operações que devem receber aviso de cancelamento. O token não pode ser usado para iniciar o cancelamento. Quando o objeto proprietário chama CancellationTokenSource.Cancel, a IsCancellationRequested propriedade em cada cópia do token de cancelamento é definida como true. Os objetos que recebem a notificação podem responder de qualquer maneira apropriada.

Para obter mais informações e exemplos de código, consulte Cancelamento em Threads Gerenciados.

Construtores

CancellationToken(Boolean)

Inicializa o CancellationToken.

Propriedades

CanBeCanceled	Determina se esse token pode estar no estado cancelado.
IsCancellationRequested	Especifica se o cancelamento foi solicitado para esse token.
None	Retorna um valor CancellationToken vazio.
WaitHandle	Obtém um WaitHandle que é sinalizado quando o token é cancelado.

Métodos

Equals(CancellationToken)	Determina se a instância CancellationToken atual é igual ao token especificado.
Equals(Object)	Determina se a instância CancellationToken atual é igual ao Object especificado.
GetHashCode()	Serve como uma função de hash para CancellationToken.
Register(Action)	Registra um delegado que será chamado quando este CancellationToken for cancelado.
Register(Action, Boolean)	Registra um delegado que será chamado quando este CancellationToken for cancelado.
Register(Action<Object,CancellationToken>, Object)	Registra um delegado que será chamado quando esse CancellationToken for cancelado.
Register(Action<Object>, Object)	Registra um delegado que será chamado quando este CancellationToken for cancelado.
Register(Action<Object>, Object, Boolean)	Registra um delegado que será chamado quando este CancellationToken for cancelado.
ThrowIfCancellationRequested()	Gera um OperationCanceledException se esse token tiver tido o cancelamento solicitado.
UnsafeRegister(Action<Object,CancellationToken>, Object)	Registra um delegado que será chamado quando esse CancellationToken for cancelado.
UnsafeRegister(Action<Object>, Object)	Registra um delegado chamado quando este CancellationToken é cancelado.

Operadores

Equality(CancellationToken, CancellationToken)	Determina se duas instâncias CancellationToken são iguais.
Inequality(CancellationToken, CancellationToken)	Determina se duas instâncias CancellationToken não são iguais.

Aplica-se a

Acesso thread-safe

Todos os membros públicos e protegidos CancellationToken são thread-safe e podem ser usados simultaneamente de vários threads.

Confira também

• Cancelamento
• Cancelamento da tarefa