CancellationTokenSource Classe

Definição

Sinaliza para um CancellationToken que ele deve ser cancelado.

public ref class CancellationTokenSource : IDisposable
public ref class CancellationTokenSource sealed : IDisposable
public class CancellationTokenSource : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public sealed class CancellationTokenSource : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public class CancellationTokenSource : IDisposable
type CancellationTokenSource = class
    interface IDisposable
[<System.Runtime.InteropServices.ComVisible(false)>]
type CancellationTokenSource = class
    interface IDisposable
Public Class CancellationTokenSource
Implements IDisposable
Public NotInheritable Class CancellationTokenSource
Implements IDisposable
Herança
CancellationTokenSource
Atributos
Implementações

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. O TaskFactory objeto, por sua vez, passa o token de cancelamento para cada uma das tarefas responsáveis por coletar leituras de 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, a chamada ao TaskFactory.ContinueWhenAll método 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 longa execução que envolvem dois objetos:

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

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 o método Dispose dele em um bloco try/catch. Para descartá-lo indiretamente, use um constructo de linguagem como using ( em C#) ou Using (em Visual Basic). Saiba mais na seção "Como usar 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 depois do atraso especificado em milissegundos.

CancellationTokenSource(TimeSpan)

Inicializa uma nova instância da classe CancellationTokenSource que será cancelada depois do intervalo de tempo especificado.

Propriedades

IsCancellationRequested

Especifica se foi solicitado cancelamento para essa CancellationTokenSource.

Token

Obtém o CancellationToken associado a este CancellationTokenSource.

Métodos

Cancel()

Comunica uma solicitação de cancelamento.

Cancel(Boolean)

Comunica uma solicitação de cancelamento e especifica se as operações canceláveis e os retornos de chamada restantes deverão 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.

CreateLinkedTokenSource(CancellationToken)

Cria um CancellationTokenSource que estará no estado cancelado quando o token fornecido estiver nesse estado.

CreateLinkedTokenSource(CancellationToken, CancellationToken)

Cria um CancellationTokenSource que estará em estado cancelado quando qualquer um dos tokens de origem estiverem no estado cancelado.

CreateLinkedTokenSource(CancellationToken[])

Cria uma CancellationTokenSource que estará em estado cancelado quando qualquer um dos tokens de origem na matriz especificada estiverem 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 Object atual.

(Herdado de Object)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)
TryReset()

Tenta redefinir a CancellationTokenSource operação a ser usada para uma operação não relacionada.

Aplica-se a

Acesso thread-safe

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

Confira também