Pourquoi CancellationToken est-il distinct de CancellationTokenSource?

Je cherche une raison pour laquelle .NET CancellationTokenstruct a été introduit en plus de la CancellationTokenSourceclasse. Je comprends comment l'API doit être utilisée, mais je veux également comprendre pourquoi elle est conçue de cette façon.

Ie, pourquoi avons-nous:

var cts = new CancellationTokenSource();
SomeCancellableOperation(cts.Token);

...
public void SomeCancellableOperation(CancellationToken token) {
    ...
    token.ThrowIfCancellationRequested();
    ...
}

au lieu de passer directement CancellationTokenSourcecomme:

var cts = new CancellationTokenSource();
SomeCancellableOperation(cts);

...
public void SomeCancellableOperation(CancellationTokenSource cts) {
    ...
    cts.ThrowIfCancellationRequested();
    ...
}

S'agit-il d'une optimisation des performances basée sur le fait que les vérifications d'état d'annulation se produisent plus fréquemment que la transmission du jeton?

Pour que cela CancellationTokenSourcepuisse suivre et mettre à jour CancellationTokens, et pour chaque jeton, le contrôle d'annulation est un accès au champ local?

Étant donné qu'un bool volatile sans verrouillage est suffisant dans les deux cas, je ne vois toujours pas pourquoi ce serait plus rapide.

Merci!

J'ai participé à la conception et à l'implémentation de ces classes.

La réponse courte est « séparation des préoccupations ». Il est bien vrai qu'il existe différentes stratégies de mise en œuvre et que certaines sont plus simples au moins en ce qui concerne le système de types et l'apprentissage initial. Cependant, CTS et CT sont destinés à être utilisés dans de nombreux scénarios (tels que les piles de bibliothèques profondes, le calcul parallèle, l'asynchrone, etc.) et ont donc été conçus avec de nombreux cas d'utilisation complexes à l'esprit. C'est une conception destinée à encourager les modèles réussis et à décourager les anti-modèles sans sacrifier les performances.

Si la porte était laissée ouverte à des API qui se comportaient mal, l'utilité de la conception d'annulation pourrait rapidement être érodée.

CancellationTokenSource == "déclenchement d'annulation", plus génère des écouteurs liés

CancellationToken == "auditeur d'annulation"

J'avais la question exacte et je voulais comprendre la raison d'être de cette conception.

La réponse acceptée a parfaitement justifié la justification. Voici la confirmation de l'équipe qui a conçu cette fonctionnalité (c'est moi qui souligne):

Deux nouveaux types forment la base du cadre: A CancellationTokenest une structure qui représente une «demande potentielle d'annulation». Cette structure est passée dans les appels de méthode en tant que paramètre et la méthode peut l'interroger ou enregistrer un rappel à déclencher lorsque l'annulation est demandée. A CancellationTokenSourceest une classe qui fournit le mécanisme pour lancer une demande d'annulation et il a une Token propriété pour obtenir un jeton associé. Il aurait été naturel de combiner ces deux classes en une seule, mais cette conception permet aux deux opérations clés (lancement d'une demande d'annulation vs observation et réponse à une annulation) d'être clairement séparées. En particulier, les méthodes qui ne prennent qu'un CancellationTokenpeut observer une demande d'annulation mais ne peuvent pas en lancer une.

Lien: Framework d'annulation .NET 4

À mon avis, le fait que l' CancellationTokenon ne puisse qu'observer l'état et ne pas le changer est extrêmement critique. Vous pouvez distribuer le jeton comme un bonbon et ne jamais craindre que quelqu'un d'autre, autre que vous, l'annule. Il vous protège du code tiers hostile. Oui, les chances sont minces, mais j'aime personnellement cette garantie.

Je pense également que cela rend l'API plus propre et évite les erreurs accidentelles et favorise une meilleure conception des composants.

Regardons l'API publique pour ces deux classes.

Si vous deviez les combiner, lors de l'écriture de LongRunningFunction, je verrai des méthodes comme ces multiples surcharges de 'Cancel' que je ne devrais pas utiliser. Personnellement, je déteste aussi voir la méthode Dispose.

Je pense que la conception actuelle de la classe suit la philosophie du «gouffre du succès», elle guide les développeurs pour créer de meilleurs composants capables de gérer l' Taskannulation, puis les instrumenter ensemble de nombreuses manières pour créer des flux de travail compliqués.

Permettez-moi de vous poser une question, vous êtes-vous demandé à quoi sert le jeton. Cela n'avait aucun sens pour moi. Et puis j'ai lu Annulation dans Managed Threads et tout est devenu limpide.

Je crois que la conception du cadre d'annulation dans TPL est absolument de premier ordre.

Ils ne sont pas séparés pour des raisons techniques mais sémantiques. Si vous regardez l'implémentation de CancellationTokenunder ILSpy, vous constaterez que c'est simplement un wrapper CancellationTokenSource(et donc pas différent en termes de performances que de passer une référence).

Ils fournissent cette séparation des fonctionnalités pour rendre les choses plus prévisibles: lorsque vous passez une méthode a CancellationToken, vous savez que vous êtes toujours le seul à pouvoir l'annuler. Bien sûr, la méthode pourrait toujours lancer un TaskCancelledException, mais CancellationTokenelle-même - et toute autre méthode référençant le même jeton - resterait sûre.

Le CancellationTokenest une structure tellement de copies pourraient exister en raison de sa transmission aux méthodes.

Les CancellationTokenSourcedéfinit l'état de toutes les copies d'un jeton lors de l' appel Cancelà la source. Voir cette page MSDN

La raison de la conception pourrait être juste une question de séparation des préoccupations et de la vitesse d'une structure.

C'est CancellationTokenSourcela «chose» qui émet l'annulation, quelle qu'en soit la raison. Il a besoin d 'un moyen d' «envoyer» cette annulation à tous les CancellationTokenmessages émis. C'est ainsi que, par exemple, ASP.NET peut annuler des opérations lorsqu'une demande est abandonnée. Chaque demande a un CancellationTokenSourcequi transmet l'annulation à tous les jetons qu'elle a émis.

C'est idéal pour les tests unitaires BTW - créez votre propre source de jeton d'annulation, obtenez un jeton, appelez Cancella source et transmettez le jeton à votre code qui doit gérer l'annulation.