CancellationTokenSource Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Signale à un CancellationToken qu'il doit être annulé.
public ref class CancellationTokenSource : IDisposable
public ref class CancellationTokenSource sealed : IDisposable
public class CancellationTokenSource : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public sealed class CancellationTokenSource : IDisposable
[System.Runtime.InteropServices.ComVisible(false)]
public class CancellationTokenSource : IDisposable
type CancellationTokenSource = class
interface IDisposable
[<System.Runtime.InteropServices.ComVisible(false)>]
type CancellationTokenSource = class
interface IDisposable
Public Class CancellationTokenSource
Implements IDisposable
Public NotInheritable 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. Une valeur de zéro indique que la mesure a échoué pour un instrument, auquel cas l’opération doit être annulée et aucune moyenne globale ne doit être calculée.
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é à un TaskFactory objet . L’objet TaskFactory transmet à son tour le jeton d’annulation à chacune des tâches responsables de la collecte des lectures pour un instrument particulier. La TaskFactory.ContinueWhenAll<TAntecedentResult,TResult>(Task<TAntecedentResult>[], Func<Task<TAntecedentResult>[],TResult>, CancellationToken) méthode est appelée pour s’assurer que la moyenne est calculée uniquement une fois que toutes les lectures ont été collectées avec succès. Si une tâche n’est pas terminée parce qu’elle a été annulée, l’appel à la TaskFactory.ContinueWhenAll méthode lève une 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 du .NET Framework 4, le .NET Framework utilise un modèle unifié pour l’annulation coopérative d’opérations synchrones asynchrones ou de longue durée qui impliquent deux objets :
Objet CancellationTokenSource , qui fournit un jeton d’annulation via sa Token propriété et envoie un message d’annulation en appelant sa Cancel méthode ou CancelAfter .
Objet CancellationToken , qui indique si l’annulation est demandée.
Le modèle général d’implémentation du modèle d’annulation coopérative est le suivant :
Instanciez un objet CancellationTokenSource qui gère et envoie une notification d'annulation pour chaque jeton d'annulation.
Passez le jeton retourné par la propriété CancellationTokenSource.Token à chaque tâche ou thread qui écoute l'annulation.
Appelez la CancellationToken.IsCancellationRequested méthode à partir d’opérations qui reçoivent le jeton d’annulation. Fournissez un mécanisme pour chaque tâche ou thread afin de répondre à une demande d’annulation. Si vous choisissez d’annuler une opération, et exactement comment vous la faites, dépend de la logique de votre application.
Appelez la méthode CancellationTokenSource.Cancel pour fournir une notification d'annulation. Cette opération définit la CancellationToken.IsCancellationRequested propriété sur chaque copie du jeton d’annulation sur
true
.Appelez la méthode Dispose une fois que vous avez terminé avec l’objet CancellationTokenSource.
Pour plus d’informations, consultez Annulation dans les threads managés.
Important
Ce type implémente l'interface IDisposable. Lorsque vous avez terminé d’utiliser une instance du type, vous devez la supprimer directement ou indirectement. Pour supprimer directement le type Dispose, appelez sa méthode dans un bloc try
/finally
. Pour la supprimer indirectement, utilisez une construction de langage telle que using
(dans C#) ou Using
(dans Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.
Constructeurs
CancellationTokenSource() |
Initialise une nouvelle instance de la classe CancellationTokenSource. |
CancellationTokenSource(Int32) |
Initialise une nouvelle instance de la classe CancellationTokenSource qui sera annulée après le délai spécifié en millisecondes. |
CancellationTokenSource(TimeSpan) |
Initialise une nouvelle instance de la classe CancellationTokenSource qui sera annulée après l'intervalle de temps spécifié. |
CancellationTokenSource(TimeSpan, TimeProvider) |
Initialise une nouvelle instance de la CancellationTokenSource classe qui sera annulée après le spécifiéTimeSpan. |
Propriétés
IsCancellationRequested |
Détermine si l'annulation a été demandée pour cette CancellationTokenSource. |
Token |
Obtient l'CancellationToken associée à cette CancellationTokenSource. |
Méthodes
Cancel() |
Transmet une demande d'annulation. |
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. |
CancelAfter(Int32) |
Planifie une opération d'annulation sur cette CancellationTokenSource après le nombre spécifié de millisecondes. |
CancelAfter(TimeSpan) |
Planifie une opération d'annulation dans ce CancellationTokenSource après l'intervalle de temps spécifié. |
CancelAsync() |
Communique une demande d’annulation de façon asynchrone. |
CreateLinkedTokenSource(CancellationToken) |
Crée un CancellationTokenSource qui sera dans l’état annulé lorsque le jeton fourni est dans l’état annulé. |
CreateLinkedTokenSource(CancellationToken, CancellationToken) |
Crée une CancellationTokenSource qui est à l'état annulé quand l'un des jetons source est à l'état annulé. |
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é. |
CreateLinkedTokenSource(ReadOnlySpan<CancellationToken>) |
Signale à un CancellationToken qu'il doit être annulé. |
Dispose() |
Libère toutes les ressources utilisées par l'instance actuelle de la classe CancellationTokenSource. |
Dispose(Boolean) |
Libère les ressources non managées utilisées par la classe CancellationTokenSource et libère éventuellement les ressources managées. |
Equals(Object) |
Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object) |
GetHashCode() |
Fait office de fonction de hachage par défaut. (Hérité de Object) |
GetType() |
Obtient le Type de l'instance actuelle. (Hérité de Object) |
MemberwiseClone() |
Crée une copie superficielle du Object actuel. (Hérité de Object) |
ToString() |
Retourne une chaîne qui représente l'objet actuel. (Hérité de Object) |
TryReset() |
Tente de réinitialiser le CancellationTokenSource à utiliser pour une opération non liée. |
S’applique à
Cohérence de thread
Tous les membres publics et protégés de CancellationTokenSource sont thread-safe et peuvent être utilisés simultanément à partir de plusieurs threads, à l’exception de Dispose(), qui ne doit être utilisé que lorsque toutes les autres opérations sur l’objet CancellationTokenSource sont terminées.
Voir aussi
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour