Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

CancellationToken structure

 

Date de publication : novembre 2016

Propage une notification indiquant que des opérations doivent être annulées.

Espace de noms:   System.Threading
Assembly:  mscorlib (dans mscorlib.dll)

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

NomDescription
System_CAPS_pubmethodCancellationToken(Boolean)

Initialise la CancellationToken.

NomDescription
System_CAPS_pubpropertyCanBeCanceled

Détermine si ce jeton peut être à l'état Annulé.

System_CAPS_pubpropertyIsCancellationRequested

Détermine si l'annulation a été demandée pour ce jeton.

System_CAPS_pubpropertySystem_CAPS_staticNone

Retourne une valeur CancellationToken vide.

System_CAPS_pubpropertyWaitHandle

Obtient un WaitHandle qui est signalé lors de l'annulation du jeton.

NomDescription
System_CAPS_pubmethodEquals(CancellationToken)

Détermine si l'instance actuelle de CancellationToken est égale au jeton spécifié.

System_CAPS_pubmethodEquals(Object)

Détermine si l'instance actuelle de CancellationToken est égale au Object spécifié.(Remplace ValueType.Equals(Object).)

System_CAPS_pubmethodGetHashCode()

Sert de fonction de hachage pour un CancellationToken.(Remplace ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodRegister(Action)

Inscrit un délégué qui sera appelé lors de l'annulation du CancellationToken.

System_CAPS_pubmethodRegister(Action, Boolean)

Inscrit un délégué qui sera appelé lors de l'annulation du CancellationToken.

System_CAPS_pubmethodRegister(Action<Object>, Object)

Inscrit un délégué qui sera appelé lors de l'annulation du CancellationToken.

System_CAPS_pubmethodRegister(Action<Object>, Object, Boolean)

Inscrit un délégué qui sera appelé lors de l'annulation du CancellationToken.

System_CAPS_pubmethodThrowIfCancellationRequested()

Lève une OperationCanceledException si l'annulation de ce jeton a été demandée.

System_CAPS_pubmethodToString()

Retourne le nom de type qualifié complet de cette instance.(Hérité de ValueType.)

NomDescription
System_CAPS_puboperatorSystem_CAPS_staticEquality(CancellationToken, CancellationToken)

Détermine si deux instances CancellationToken sont égales.

System_CAPS_puboperatorSystem_CAPS_staticInequality(CancellationToken, CancellationToken)

Détermine si les deux instances de CancellationToken ne sont pas égales.

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.

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 4.0
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 5.0
Silverlight pour Windows Phone
Disponible depuis 8.0
Windows Phone
Disponible depuis 8.1

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

Retour au début
Afficher: