Comment utiliser la propriété CancellationToken?

Par rapport au code précédent pour la classe RulyCanceler , je voulais exécuter du code en utilisant CancellationTokenSource.

Comment puis-je l'utiliser comme mentionné dans les jetons d'annulation , c'est-à-dire sans lancer / attraper une exception? Puis-je utiliser la IsCancellationRequestedpropriété?

J'ai essayé de l'utiliser comme ceci:

cancelToken.ThrowIfCancellationRequested();

et

try
{
  new Thread(() => Work(cancelSource.Token)).Start();
}
catch (OperationCanceledException)
{
  Console.WriteLine("Canceled!");
}

mais cela a donné une erreur d'exécution sur la cancelToken.ThrowIfCancellationRequested();méthode Work(CancellationToken cancelToken):

System.OperationCanceledException was unhandled
  Message=The operation was canceled.
  Source=mscorlib
  StackTrace:
       at System.Threading.CancellationToken.ThrowIfCancellationRequested()
       at _7CancellationTokens.Token.Work(CancellationToken cancelToken) in C:\xxx\Token.cs:line 33
       at _7CancellationTokens.Token.<>c__DisplayClass1.<Main>b__0() in C:\xxx\Token.cs:line 22
       at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
       at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean ignoreSyncCtx)
       at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
       at System.Threading.ThreadHelper.ThreadStart()
  InnerException:

Le code que j'ai exécuté avec succès a attrapé l'exception OperationCanceledException dans le nouveau thread:

using System;
using System.Threading;
namespace _7CancellationTokens
{
  internal class Token
  {
    private static void Main()
    {
      var cancelSource = new CancellationTokenSource();
      new Thread(() =>
      {
         try
         {
           Work(cancelSource.Token); //).Start();
         }
         catch (OperationCanceledException)
         {
            Console.WriteLine("Canceled!");
         }
         }).Start();

      Thread.Sleep(1000);
      cancelSource.Cancel(); // Safely cancel worker.
      Console.ReadLine();
    }
    private static void Work(CancellationToken cancelToken)
    {
      while (true)
      {
        Console.Write("345");
        cancelToken.ThrowIfCancellationRequested();
      }
    }
  }
}

Vous pouvez implémenter votre méthode de travail comme suit:

private static void Work(CancellationToken cancelToken)
{
    while (true)
    {
        if(cancelToken.IsCancellationRequested)
        {
            return;
        }
        Console.Write("345");
    }
}

C'est tout. Vous devez toujours gérer l'annulation par vous-même - quitter la méthode au moment opportun pour quitter (afin que votre travail et vos données soient dans un état cohérent)

MISE À JOUR: Je préfère ne pas écrire while (!cancelToken.IsCancellationRequested)car il y a souvent peu de points de sortie où vous pouvez arrêter de s'exécuter en toute sécurité sur le corps de la boucle, et la boucle a généralement une condition logique pour quitter (itérer sur tous les éléments de la collection, etc.). Je pense donc qu'il vaut mieux ne pas mélanger ces conditions car elles ont une intention différente.

Attention à éviter CancellationToken.ThrowIfCancellationRequested():

Commentaire en question par Eamon Nerbonne :

... remplaçant gracieusement ThrowIfCancellationRequestedpar un tas de vérifications pour les IsCancellationRequestedsorties, comme le dit cette réponse. Mais ce n'est pas seulement un détail de mise en œuvre; qui affecte le comportement observable: la tâche ne se terminera plus dans l'état annulé, mais dans RanToCompletion. Et cela peut affecter non seulement les vérifications d'état explicites, mais aussi, plus subtilement, l'enchaînement des tâches avec par exemple ContinueWith, en fonction de l' TaskContinuationOptionsutilisation. Je dirais qu'éviter ThrowIfCancellationRequestedest un conseil dangereux.

@ BrainSlugs83

Vous ne devriez pas faire confiance aveuglément à tout ce qui est publié sur stackoverflow. Le commentaire dans le code Jens est incorrect, le paramètre ne contrôle pas si les exceptions sont levées ou non.

MSDN est très clair ce que contrôle ce paramètre, l'avez-vous lu? http://msdn.microsoft.com/en-us/library/dd321703(v=vs.110).aspx

Si la valeur throwOnFirstExceptionest true, une exception se propage immédiatement hors de l'appel à Cancel, empêchant le traitement des rappels restants et des opérations annulables. Si throwOnFirstExceptionest false, cette surcharge agrégera toutes les exceptions levées dans un AggregateException, de sorte qu'un rappel lançant une exception n'empêchera pas l'exécution d'autres rappels enregistrés.

Le nom de la variable est également erroné car Cancel n'est pas appelé sur CancellationTokenSourcele jeton lui-même et la source change l'état de chaque jeton qu'elle gère.

Vous pouvez créer une tâche avec un jeton d'annulation, lorsque vous passez en arrière-plan, vous pouvez annuler ce jeton.

Vous pouvez le faire dans PCL https://developer.xamarin.com/guides/xamarin-forms/application-fundamentals/app-lifecycle

var cancelToken = new CancellationTokenSource();
Task.Factory.StartNew(async () => {
    await Task.Delay(10000);
    // call web API
}, cancelToken.Token);

//this stops the Task:
cancelToken.Cancel(false);

Une autre solution est le minuteur utilisateur dans Xamarin.Forms, arrêtez le minuteur lorsque l'application est en arrière-plan https://xamarinhelp.com/xamarin-forms-timer/

Vous pouvez utiliser ThrowIfCancellationRequestedsans gérer l'exception!

L'utilisation de ThrowIfCancellationRequestedest destinée à être utilisée à partir d'un Task(et non d'un Thread). Lorsqu'il est utilisé dans a Task, vous ne devez pas gérer l'exception vous-même (et obtenir l'erreur Exception non gérée). Cela entraînera la sortie de Task, et la Task.IsCancelledpropriété sera True. Aucune gestion d'exception requise.

Dans votre cas spécifique, remplacez le Threadpar un Task.

Task t = null;
try
{
    t = Task.Run(() => Work(cancelSource.Token), cancelSource.Token);
}

if (t.IsCancelled)
{
    Console.WriteLine("Canceled!");
}

Vous devez transmettre le CancellationTokenà la tâche, qui surveillera périodiquement le jeton pour voir si l'annulation est demandée.

CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken token = cancellationTokenSource.Token;  
Task task = Task.Run(() => {     
  while(!token.IsCancellationRequested) {
      Console.Write("*");         
      Thread.Sleep(1000);
  }
}, token);
Console.WriteLine("Press enter to stop the task"); 
Console.ReadLine(); 
cancellationTokenSource.Cancel(); 

Dans ce cas, l'opération se terminera lorsque l'annulation sera demandée et le Taskaura un RanToCompletionétat. Si vous voulez être reconnu que votre tâche a été annulée , vous devez utiliser ThrowIfCancellationRequestedpour lever une OperationCanceledExceptionexception.

Task task = Task.Run(() =>             
{                 
    while (!token.IsCancellationRequested) {
         Console.Write("*");                      
        Thread.Sleep(1000);                 
    }           
    token.ThrowIfCancellationRequested();               
}, token)
.ContinueWith(t =>
 {
      t.Exception?.Handle(e => true);
      Console.WriteLine("You have canceled the task");
 },TaskContinuationOptions.OnlyOnCanceled);  

Console.WriteLine("Press enter to stop the task");                 
Console.ReadLine();                 
cancellationTokenSource.Cancel();                 
task.Wait(); 

J'espère que cela aide à mieux comprendre.