CancellationTokenSource Classe

Definição

Sinaliza para um CancellationToken que ele deve ser cancelado.Signals to a CancellationToken that it should be canceled.

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

Exemplos

O exemplo a seguir usa um gerador de números aleatórios para emular um aplicativo de coleta de dados que lê 10 valores integrais de onze instrumentos diferentes.The following example uses a random number generator to emulate a data collection application that reads 10 integral values from eleven different instruments. Um valor de zero indica que a medição falhou para um instrumento; nesse caso, a operação deve ser cancelada e nenhuma média geral deve ser computada.A value of zero indicates that the measurement has failed for one instrument, in which case the operation should be cancelled and no overall mean should be computed.

Para lidar com o cancelamento possível da operação, o exemplo instancia um objeto CancellationTokenSource que gera um token de cancelamento que é passado para um objeto TaskFactory.To handle the possible cancellation of the operation, the example instantiates a CancellationTokenSource object that generates a cancellation token which is passed to a TaskFactory object. O objeto TaskFactory, por sua vez, passa o token de cancelamento para cada uma das tarefas responsáveis pela coleta de leituras de um instrumento específico.The TaskFactory object in turn passes the cancellation token to each of the tasks responsible for collecting readings for a particular instrument. O método TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) é chamado para garantir que a média seja calculada somente depois que todas as leituras tiverem sido reunidas com êxito.The TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) method is called to ensure that the mean is computed only after all readings have been gathered successfully. Se uma tarefa não tiver sido cancelada, a chamada para o método TaskFactory.ContinueWhenAll lançará uma exceção.If a task has not because it has been cancelled, the call to the TaskFactory.ContinueWhenAll method throws an exception.

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.NET Framework 4, o .NET Framework usa um modelo unificado para o cancelamento cooperativo de operações síncronas ou síncronas de execução longa que envolvem dois objetos:Starting with the .NET Framework 4.NET Framework 4, the .NET Framework uses a unified model for cooperative cancellation of asynchronous or long-running synchronous operations that involves two objects:

O padrão geral para implementar o modelo de cancelamento cooperativo é:The general pattern for implementing the cooperative cancellation model is:

Para saber mais, confira Cancelamento em threads gerenciados.For more information, see Cancellation in Managed Threads.

Importante

Esse tipo implementa a interface IDisposable.This type implements the IDisposable interface. Quando você terminar de usar uma instância do tipo, deverá descartá-la direta ou indiretamente.When you have finished using an instance of the type, you should dispose of it either directly or indirectly. Para descartar o tipo diretamente, chame o método Dispose dele em um bloco try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Para descartá-lo indiretamente, use um constructo de linguagem como using ( em C#) ou Using (em Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Saiba mais na seção "Como usar um objeto que implementa IDisposable" no tópico da interface IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Construtores

CancellationTokenSource()

Inicializa uma nova instância da classe CancellationTokenSource.Initializes a new instance of the CancellationTokenSource class.

CancellationTokenSource(Int32)

Inicializa uma nova instância da classe CancellationTokenSource que será cancelada depois do atraso especificado em milissegundos.Initializes a new instance of the CancellationTokenSource class that will be canceled after the specified delay in milliseconds.

CancellationTokenSource(TimeSpan)

Inicializa uma nova instância da classe CancellationTokenSource que será cancelada depois do intervalo de tempo especificado.Initializes a new instance of the CancellationTokenSource class that will be canceled after the specified time span.

Propriedades

IsCancellationRequested

Especifica se foi solicitado cancelamento para essa CancellationTokenSource.Gets whether cancellation has been requested for this CancellationTokenSource.

Token

Obtém o CancellationToken associado a este CancellationTokenSource.Gets the CancellationToken associated with this CancellationTokenSource.

Métodos

Cancel()

Comunica uma solicitação de cancelamento.Communicates a request for cancellation.

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.Communicates a request for cancellation, and specifies whether remaining callbacks and cancelable operations should be processed if an exception occurs.

CancelAfter(Int32)

Agenda uma operação de cancelamento neste CancellationTokenSource após o número especificado de milissegundos.Schedules a cancel operation on this CancellationTokenSource after the specified number of milliseconds.

CancelAfter(TimeSpan)

Agenda uma operação de cancelamento neste CancellationTokenSource após o período de tempo especificado.Schedules a cancel operation on this CancellationTokenSource after the specified time span.

CreateLinkedTokenSource(CancellationToken, CancellationToken)

Cria um CancellationTokenSource que estará em estado cancelado quando qualquer um dos tokens de origem estiverem no estado cancelado.Creates a CancellationTokenSource that will be in the canceled state when any of the source tokens are in the canceled state.

CreateLinkedTokenSource(CancellationToken[])

Cria uma CancellationTokenSource que estará em estado cancelado quando qualquer um dos tokens de origem na matriz especificada estiverem no estado cancelado.Creates a CancellationTokenSource that will be in the canceled state when any of the source tokens in the specified array are in the canceled state.

Dispose()

Libera todos os recursos usados pela instância atual da classe CancellationTokenSource.Releases all resources used by the current instance of the CancellationTokenSource class.

Dispose(Boolean)

Libera os recursos não gerenciados usados pela classe CancellationTokenSource e, opcionalmente, libera os recursos gerenciados.Releases the unmanaged resources used by the CancellationTokenSource class and optionally releases the managed resources.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Herdado de Object)

Aplica-se a

Acesso thread-safe

Todos os membros públicos e protegidos do 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 objeto CancellationTokenSource forem concluídas.All public and protected members of CancellationTokenSource are thread-safe and may be used concurrently from multiple threads, with the exception of Dispose(), which must only be used when all other operations on the CancellationTokenSource object have completed.

Veja também