CancellationTokenSource Classe

Definição

Namespace:

System.Threading

Assembly:

System.Runtime.dll

Origem:

CancellationTokenSource.cs

Sinaliza para um CancellationToken que ele deve ser cancelado.

public ref class CancellationTokenSource : IDisposable

public class CancellationTokenSource : IDisposable

type CancellationTokenSource = class
    interface IDisposable

Public Class CancellationTokenSource
Implements 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.

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.

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      ' Define the cancellation token.
      Dim source As New CancellationTokenSource()
      Dim token As CancellationToken = source.Token

      Dim lockObj As New Object()
      Dim rnd As New Random

      Dim tasks As New List(Of Task(Of Integer()))
      Dim factory As New TaskFactory(token)
      For taskCtr As Integer = 0 To 10
         Dim iteration As Integer = taskCtr + 1
         tasks.Add(factory.StartNew(Function()
                                       Dim value, values(9) As Integer
                                       For ctr As Integer = 1 To 10
                                          SyncLock lockObj
                                             value = rnd.Next(0,101)
                                          End SyncLock
                                          If value = 0 Then 
                                             source.Cancel
                                             Console.WriteLine("Cancelling at task {0}", iteration)
                                             Exit For
                                          End If   
                                          values(ctr-1) = value 
                                       Next
                                       Return values
                                    End Function, token))   
         
      Next
      Try
         Dim fTask As Task(Of Double) = factory.ContinueWhenAll(tasks.ToArray(), 
                                                         Function(results)
                                                            Console.WriteLine("Calculating overall mean...")
                                                            Dim sum As Long
                                                            Dim n As Integer 
                                                            For Each t In results
                                                               For Each r In t.Result
                                                                  sum += r
                                                                  n+= 1
                                                               Next
                                                            Next
                                                            Return sum/n
                                                         End Function, token)
         Console.WriteLine("The mean is {0}.", fTask.Result)
      Catch ae As AggregateException
         For Each e In ae.InnerExceptions
            If TypeOf e Is TaskCanceledException
               Console.WriteLine("Unable to compute mean: {0}", 
                                 CType(e, TaskCanceledException).Message)
            Else
               Console.WriteLine("Exception: " + e.GetType().Name)
            End If   
         Next
      Finally
         source.Dispose()
      End Try                                                          
   End Sub
End Module
' 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.

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