CancellationTokenSource Classe

Definição

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

Object

CancellationTokenSource

Atributos

ComVisibleAttribute

Implementações

IDisposable

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 CancellationTokenSource objeto que gera um token de cancelamento que é passado para um TaskFactory objeto.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 TaskFactory objeto, 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 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 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 TaskFactory.ContinueWhenAll método 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 de execução longa de longas duração 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:

• Um CancellationTokenSource objeto, que fornece um token de cancelamento por meio de sua Token propriedade e envia uma mensagem de cancelamento chamando seu Cancel CancelAfter método or.A CancellationTokenSource object, which provides a cancellation token through its Token property and sends a cancellation message by calling its Cancel or CancelAfter method.

• Um CancellationToken objeto, que indica se o cancelamento é solicitado.A CancellationToken object, which indicates whether cancellation is requested.

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

• Instancie um objeto CancellationTokenSource, que gerencia e envia uma notificação de cancelamento para os tokens de cancelamento individuais.Instantiate a CancellationTokenSource object, which manages and sends cancellation notification to the individual cancellation tokens.

• Passe o token retornado pela propriedade CancellationTokenSource.Token para cada tarefa ou thread que responde ao cancelamento.Pass the token returned by the CancellationTokenSource.Token property to each task or thread that listens for cancellation.

• Chame o CancellationToken.IsCancellationRequested método de operações que recebem o token de cancelamento.Call the CancellationToken.IsCancellationRequested method from operations that receive the cancellation token. Forneça um mecanismo para cada tarefa ou thread para responder a uma solicitação de cancelamento.Provide a mechanism for each task or thread to respond to a cancellation request. Se você optar por cancelar uma operação e exatamente como faz isso, dependerá da lógica do aplicativo.Whether you choose to cancel an operation, and exactly how you do it, depends on your application logic.

• Chame o método CancellationTokenSource.Cancel para fornecer uma notificação de cancelamento.Call the CancellationTokenSource.Cancel method to provide notification of cancellation. Isso define a CancellationToken.IsCancellationRequested propriedade em cada cópia do token de cancelamento para true .This sets the CancellationToken.IsCancellationRequested property on every copy of the cancellation token to true.

• Chame o Dispose método quando terminar com o CancellationTokenSource objeto.Call the Dispose method when you are finished with the CancellationTokenSource object.

Para obter mais informações, consulte cancelamento em threads gerenciados.For more information, see Cancellation in Managed Threads.

Construtores

Propriedades

Métodos

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 a exceção de Dispose() , que deve ser usada somente quando todas as outras operações no CancellationTokenSource objeto 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.

Confira também

• CancelamentoCancellation
• Cancelamento da tarefaTask Cancellation