Partilhar via


CancellationToken Estrutura

Definição

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

public value class CancellationToken
public value class CancellationToken : IEquatable<System::Threading::CancellationToken>
public struct CancellationToken
public readonly struct CancellationToken
public readonly struct CancellationToken : IEquatable<System.Threading.CancellationToken>
[System.Runtime.InteropServices.ComVisible(false)]
public struct CancellationToken
type CancellationToken = struct
[<System.Runtime.InteropServices.ComVisible(false)>]
type CancellationToken = struct
Public Structure CancellationToken
Public Structure CancellationToken
Implements IEquatable(Of CancellationToken)
Herança
CancellationToken
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. 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.

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

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