CancellationTokenSource Classe

Définition

Signale à un CancellationToken qu'il doit être annulé.Signals to a CancellationToken that it should be canceled.

public ref class CancellationTokenSource : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public class CancellationTokenSource : IDisposable
type CancellationTokenSource = class
    interface IDisposable
Public Class CancellationTokenSource
Implements IDisposable
Héritage
CancellationTokenSource
Attributs
Implémente

Exemples

L’exemple suivant utilise un générateur de nombres aléatoires pour émuler une application de collecte de données qui lit 10 valeurs intégrales à partir de onze instruments différents.The following example uses a random number generator to emulate a data collection application that reads 10 integral values from eleven different instruments. La valeur zéro indique que la mesure a échoué pour un instrument. dans ce cas, l’opération doit être annulée et aucune moyenne globale ne doit être calculée.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.

Pour gérer l’annulation possible de l’opération, l’exemple instancie un CancellationTokenSource objet qui génère un jeton d’annulation qui est passé à TaskFactory un objet.To handle the possible cancellation of the operation, the example instantiates a CancellationTokenSource object that generates a cancellation token which is passed to a TaskFactory object. L' TaskFactory objet transmet ensuite le jeton d’annulation à chacune des tâches responsables de la collecte des lectures d’un instrument particulier.The TaskFactory object in turn passes the cancellation token to each of the tasks responsible for collecting readings for a particular instrument. La TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) méthode est appelée pour garantir que la moyenne est calculée uniquement une fois que toutes les lectures ont été collectées avec succès.The TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) method is called to ensure that the mean is computed only after all readings have been gathered successfully. Si une tâche n’a pas été annulée, l’appel à la TaskFactory.ContinueWhenAll méthode lève une exception.If a task has not because it has been cancelled, the call to the TaskFactory.ContinueWhenAll 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.
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.

Remarques

À compter de, le .NET Framework utilise un modèle unifié pour l’annulation coopérative des opérations synchrones asynchrones ou à long terme qui impliquent deux objets: .NET Framework 4.NET Framework 4Starting with the .NET Framework 4.NET Framework 4, the .NET Framework uses a unified model for cooperative cancellation of asynchronous or long-running synchronous operations that involves two objects:

Le modèle général d’implémentation du modèle d’annulation coopérative est le suivant :The general pattern for implementing the cooperative cancellation model is:

Pour plus d’informations, consultez Annulation dans les threads managés.For more information, see Cancellation in Managed Threads.

Important

Ce type implémente l' IDisposable interface.This type implements the IDisposable interface. Lorsque vous avez fini d’utiliser une instance du type, vous devez la supprimer directement ou indirectement.When you have finished using an instance of the type, you should dispose of it either directly or indirectly. Pour supprimer directement le Dispose type, appelez sa méthode dans un try / catch bloc.To dispose of the type directly, call its Dispose method in a try/catch block. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Pour plus d’informations, consultez la section «utilisation d’un objet qui implémente IDisposable» IDisposable dans la rubrique de l’interface.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Constructeurs

CancellationTokenSource()

Initialise une nouvelle instance de la classe CancellationTokenSource.Initializes a new instance of the CancellationTokenSource class.

CancellationTokenSource(Int32)

Initialise une nouvelle instance de la classe CancellationTokenSource qui sera annulée après que le délai spécifié en millisecondes.Initializes a new instance of the CancellationTokenSource class that will be canceled after the specified delay in milliseconds.

CancellationTokenSource(TimeSpan)

Initialise une nouvelle instance de la classe CancellationTokenSource qui sera annulée après l'intervalle de temps spécifié.Initializes a new instance of the CancellationTokenSource class that will be canceled after the specified time span.

Propriétés

IsCancellationRequested

Détermine si l'annulation a été demandée pour cette CancellationTokenSource.Gets whether cancellation has been requested for this CancellationTokenSource.

Token

Obtient l'CancellationToken associée à cette CancellationTokenSource.Gets the CancellationToken associated with this CancellationTokenSource.

Méthodes

Cancel()

Transmet une demande d'annulation.Communicates a request for cancellation.

Cancel(Boolean)

Communique une demande d’annulation, et spécifie si les rappels restants et les opérations annulables doivent être traités si une exception se produit.Communicates a request for cancellation, and specifies whether remaining callbacks and cancelable operations should be processed if an exception occurs.

CancelAfter(Int32)

Planifie une opération d'annulation dans ce CancellationTokenSource après le nombre spécifié de millisecondes.Schedules a cancel operation on this CancellationTokenSource after the specified number of milliseconds.

CancelAfter(TimeSpan)

Planifie une opération d'annulation dans ce CancellationTokenSource après l'intervalle de temps spécifié.Schedules a cancel operation on this CancellationTokenSource after the specified time span.

CreateLinkedTokenSource(CancellationToken, CancellationToken)

Crée une CancellationTokenSource qui est à l'état annulé quand l'un des jetons source est à l'état annulé.Creates a CancellationTokenSource that will be in the canceled state when any of the source tokens are in the canceled state.

CreateLinkedTokenSource(CancellationToken[])

Crée une CancellationTokenSource qui sera à l'état annulé lorsque l'un des jetons source du tableau spécifié est à l'état annulé.Creates a CancellationTokenSource that will be in the canceled state when any of the source tokens in the specified array are in the canceled state.

Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe CancellationTokenSource.Releases all resources used by the current instance of the CancellationTokenSource class.

Dispose(Boolean)

Libère les ressources non managées utilisées par la classe CancellationTokenSource et libère éventuellement les ressources managées.Releases the unmanaged resources used by the CancellationTokenSource class and optionally releases the managed resources.

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)

S’applique à

Cohérence de thread

Tous les membres publics et protégés CancellationTokenSource de sont thread-safe et peuvent être utilisés simultanément à partir de plusieurs threads, à l' Dispose()exception de, qui ne doit être utilisé que lorsque toutes les CancellationTokenSource autres opérations sur l’objet sont terminées.All public and protected members of CancellationTokenSource are thread-safe and may be used concurrently from multiple threads, with the exception of Dispose(), which must only be used when all other operations on the CancellationTokenSource object have completed.

Voir aussi