Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Estructura CancellationToken

 

Publicado: octubre de 2016

Propaga la notificación de que las operaciones deberían cancelarse.

Espacio de nombres:   System.Threading
Ensamblado:  mscorlib (en mscorlib.dll)

[ComVisibleAttribute(false)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public struct CancellationToken

NombreDescripción
System_CAPS_pubmethodCancellationToken(Boolean)

Inicializa el CancellationToken.

NombreDescripción
System_CAPS_pubpropertyCanBeCanceled

Obtiene si este token es capaz de existir en el estado cancelado.

System_CAPS_pubpropertyIsCancellationRequested

Obtiene si se ha solicitado la cancelación para este token.

System_CAPS_pubpropertySystem_CAPS_staticNone

Devuelve un valor CancellationToken vacío.

System_CAPS_pubpropertyWaitHandle

Obtiene un WaitHandle que se señala cuando el token se cancela.

NombreDescripción
System_CAPS_pubmethodEquals(CancellationToken)

Determina si la instancia de CancellationToken actual es igual que el token especificado.

System_CAPS_pubmethodEquals(Object)

Determina si la instancia de CancellationToken actual es igual que la instancia de Object especificada.(Invalida ValueType.Equals(Object)).

System_CAPS_pubmethodGetHashCode()

Sirve como función hash de un objeto CancellationToken.(Invalida ValueType.GetHashCode()).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodRegister(Action)

Registra un delegado que se invocará cuando se cancele este objeto CancellationToken.

System_CAPS_pubmethodRegister(Action, Boolean)

Registra un delegado que se invocará cuando se cancele este objeto CancellationToken.

System_CAPS_pubmethodRegister(Action<Object>, Object)

Registra un delegado que se invocará cuando se cancele este objeto CancellationToken.

System_CAPS_pubmethodRegister(Action<Object>, Object, Boolean)

Registra un delegado que se invocará cuando se cancele este objeto CancellationToken.

System_CAPS_pubmethodThrowIfCancellationRequested()

Produce OperationCanceledException si este token ha tenido una solicitud de cancelación.

System_CAPS_pubmethodToString()

Devuelve el nombre de tipo completo de esta instancia.(Heredado de ValueType).

NombreDescripción
System_CAPS_puboperatorSystem_CAPS_staticEquality(CancellationToken, CancellationToken)

Determina si dos instancias de CancellationToken son iguales.

System_CAPS_puboperatorSystem_CAPS_staticInequality(CancellationToken, CancellationToken)

Determina si dos instancias de CancellationToken no son iguales.

A T:System.Threading.CancellationToken enables cooperative cancellation between threads, thread pool work items, or T:System.Threading.Tasks.Task objects. You create a cancellation token by instantiating a T:System.Threading.CancellationTokenSource object, which manages cancellation tokens retrieved from its P:System.Threading.CancellationTokenSource.Token property. You then pass the cancellation token to any number of threads, tasks, or operations that should receive notice of cancellation. The token cannot be used to initiate cancellation. When the owning object calls M:System.Threading.CancellationTokenSource.Cancel, the P:System.Threading.CancellationToken.IsCancellationRequested property on every copy of the cancellation token is set to true. The objects that receive the notification can respond in whatever manner is appropriate.

For more information and code examples see Cancellation.

The following example uses a random number generator to emulate a data collection application that reads 10 integral values from eleven different instruments. 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.

To handle the possible cancellation of the operation, the example instantiates a T:System.Threading.CancellationTokenSource object that generates a cancellation token which is passed to a T:System.Threading.Tasks.TaskFactory object. The T:System.Threading.Tasks.TaskFactory object in turn passes the cancellation token to each of the tasks responsible for collecting readings for a particular instrument. The M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken) method is called to ensure that the mean is computed only after all readings have been gathered successfully. If a task has not because it has been cancelled, the call to the M:System.Threading.Tasks.TaskFactory.ContinueWhenAll``2(System.Threading.Tasks.Task{``0}[],System.Func{System.Threading.Tasks.Task{``0}[],``1},System.Threading.CancellationToken) 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.

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 4.0
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 5.0
Windows Phone Silverlight
Disponible desde 8.0
Windows Phone
Disponible desde 8.1

All public and protected members of T:System.Threading.CancellationToken are thread-safe and may be used concurrently from multiple threads.

Volver al principio
Mostrar: