Compartir a través de


CancellationTokenSource.Cancel Método

Definición

Comunica una solicitud de cancelación.

Sobrecargas

Cancel()

Comunica una solicitud de cancelación.

Cancel(Boolean)

Comunica una solicitud de cancelación y especifica si se deben procesar las devoluciones de llamada restantes y las operaciones cancelables si se produce una excepción.

Cancel()

Comunica una solicitud de cancelación.

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

Excepciones

Esta interfaz CancellationTokenSource se ha eliminado.

Una excepción agregada que contiene todas las excepciones producidas por las devoluciones de llamada registradas en el CancellationToken asociado.

Ejemplos

En el ejemplo siguiente se usa un generador de números aleatorios para emular una aplicación de recopilación de datos que lee 10 valores enteros de once instrumentos diferentes. Un valor de cero indica que se ha producido un error en la medida de un instrumento, en cuyo caso se debe cancelar la operación y no se debe calcular ninguna media global.

Para controlar la posible cancelación de la operación, en el ejemplo se crea una instancia de un CancellationTokenSource objeto que genera un token de cancelación que se pasa a un TaskFactory objeto . A TaskFactory su vez, el objeto pasa el token de cancelación a cada una de las tareas responsables de recopilar lecturas de un instrumento determinado. Se TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) llama al método para asegurarse de que la media se calcula solo después de que todas las lecturas se hayan recopilado correctamente. Si una tarea no se ha cancelado, la llamada al TaskFactory.ContinueWhenAll método produce una excepción.

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.

Comentarios

El asociado CancellationToken recibirá una notificación de la cancelación y pasará a un estado donde IsCancellationRequested devuelve true.

Se ejecutarán las devoluciones de llamada o las operaciones cancelables registradas con .CancellationToken

Se recomienda que las operaciones cancelables y las devoluciones de llamada registradas sin CancellationToken iniciar excepciones.

Esta sobrecarga de Cancel agregará las excepciones producidas en un , AggregateExceptionde modo que una devolución de llamada que produzca una excepción no impedirá que se ejecuten otras devoluciones de llamada registradas.

Llamar a este método tiene el mismo efecto que llamar a Cancel(false).

Consulte también

Se aplica a

Cancel(Boolean)

Comunica una solicitud de cancelación y especifica si se deben procesar las devoluciones de llamada restantes y las operaciones cancelables si se produce una excepción.

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 si las excepciones se propagan inmediatamente; si no, false.

Excepciones

Esta interfaz CancellationTokenSource se ha eliminado.

Una excepción agregada que contiene todas las excepciones producidas por las devoluciones de llamada registradas en el CancellationToken asociado.

Comentarios

El asociado CancellationToken recibirá una notificación de la cancelación y pasará a un estado donde IsCancellationRequested devuelve true.

Se ejecutarán las devoluciones de llamada o las operaciones cancelables registradas con .CancellationToken Las devoluciones de llamada se ejecutarán de forma sincrónica en orden LIFO.

Se recomienda que las operaciones cancelables y las devoluciones de llamada registradas sin CancellationToken iniciar excepciones.

Si throwOnFirstException es true, una excepción se propagará inmediatamente fuera de la llamada a Cancel, lo que impide que se procesen las devoluciones de llamada restantes y las operaciones cancelables.

Si throwOnFirstException es false, esta sobrecarga agregará las excepciones producidas en un AggregateException, de modo que una devolución de llamada que produzca una excepción no impedirá que se ejecuten otras devoluciones de llamada registradas.

Consulte también

Se aplica a