Compartilhar via


CancellationTokenSource.Cancel Método

Definição

Comunica uma solicitação de cancelamento.

Sobrecargas

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.

Cancel()

Comunica uma solicitação de cancelamento.

public:
 void Cancel();
public void Cancel ();
member this.Cancel : unit -> unit
Public Sub Cancel ()

Exceções

Uma exceção de agregação que contém todas as exceções geradas pelos retornos de chamada registrados no CancellationToken associado.

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 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

Os associados CancellationToken serão notificados sobre o cancelamento e farão a transição para um estado em que IsCancellationRequested retornará true.

Quaisquer retornos de chamada ou operações canceláveis registradas com o CancellationToken serão executadas.

Recomendamos que operações canceláveis e retornos de chamada registrados sem CancellationToken exceções não sejam geradas.

Essa sobrecarga de Cancelar agregará todas as exceções geradas em um AggregateException, de modo que um retorno de chamada gerando uma exceção não impedirá que outros retornos de chamada registrados sejam executados.

Chamar esse método tem o mesmo efeito que chamar Cancel(false).

Confira também

Aplica-se a

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.

public:
 void Cancel(bool throwOnFirstException);
public void Cancel (bool throwOnFirstException);
member this.Cancel : bool -> unit
Public Sub Cancel (throwOnFirstException As Boolean)

Parâmetros

throwOnFirstException
Boolean

true se exceções devem propagar imediatamente; caso contrário, false.

Exceções

Uma exceção de agregação que contém todas as exceções geradas pelos retornos de chamada registrados no CancellationToken associado.

Comentários

O associado CancellationToken será notificado do cancelamento e fará a transição para um estado em que IsCancellationRequested retornará true.

Quaisquer retornos de chamada ou operações canceláveis registradas com o CancellationToken serão executadas. Os retornos de chamada serão executados de forma síncrona na ordem LIFO.

Recomendamos que operações canceláveis e retornos de chamada registrados sem CancellationToken exceções não sejam geradas.

Se throwOnFirstException for true, uma exceção será imediatamente propagada para fora da chamada, Cancelimpedindo que os retornos de chamada restantes e as operações canceláveis sejam processados.

Se throwOnFirstException for false, essa sobrecarga agregará quaisquer exceções geradas em um AggregateException, de modo que um retorno de chamada gerando uma exceção não impedirá que outros retornos de chamada registrados sejam executados.

Confira também

Aplica-se a