Come utilizzare la proprietà CancellationToken?

Rispetto al codice precedente per la classe RulyCanceler , volevo eseguire il codice utilizzando CancellationTokenSource.

Come lo uso come menzionato in Token di cancellazione , cioè senza lanciare / catturare un'eccezione? Posso usare la IsCancellationRequestedproprietà?

Ho provato a usarlo in questo modo:

cancelToken.ThrowIfCancellationRequested();

e

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

ma questo ha dato un errore di runtime cancelToken.ThrowIfCancellationRequested();nel metodo 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:

Il codice che ho eseguito con successo ha catturato OperationCanceledException nel nuovo 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();
      }
    }
  }
}

Puoi implementare il tuo metodo di lavoro come segue:

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

Questo è tutto. Devi sempre gestire la cancellazione da solo - esci dal metodo quando è il momento opportuno per uscire (in modo che il tuo lavoro ei tuoi dati siano in uno stato coerente)

AGGIORNAMENTO: preferisco non scrivere while (!cancelToken.IsCancellationRequested)perché spesso ci sono pochi punti di uscita in cui è possibile interrompere l'esecuzione in modo sicuro attraverso il corpo del ciclo e il ciclo di solito ha una condizione logica per uscire (iterare su tutti gli elementi nella raccolta ecc.). Quindi credo che sia meglio non mescolare queste condizioni perché hanno intenzioni diverse.

Nota cautelativa su come evitare CancellationToken.ThrowIfCancellationRequested():

Commento in questione di Eamon Nerbonne :

... sostituendo ThrowIfCancellationRequestedcon un mucchio di controlli per le IsCancellationRequesteduscite con garbo, come dice questa risposta. Ma non è solo un dettaglio di implementazione; che influisce sul comportamento osservabile: l'attività non terminerà più nello stato annullato, ma in RanToCompletion. E questo può influenzare non solo i controlli di stato espliciti, ma anche, in modo più sottile, il concatenamento di attività con ContinueWith, ad esempio , a seconda TaskContinuationOptionsdell'uso. Direi che evitare ThrowIfCancellationRequestedè un consiglio pericoloso.

@ BrainSlugs83

Non dovresti fidarti ciecamente di tutto ciò che viene pubblicato su stackoverflow. Il commento nel codice Jens non è corretto, il parametro non controlla se le eccezioni vengono lanciate o meno.

MSDN è molto chiaro cosa controlla quel parametro, l'hai letto? http://msdn.microsoft.com/en-us/library/dd321703(v=vs.110).aspx

Se throwOnFirstExceptionè vero, un'eccezione si propagherà immediatamente fuori dalla chiamata a Cancel, impedendo l'elaborazione delle restanti callback e operazioni cancellabili. Se throwOnFirstExceptionè false, questo overload aggregherà tutte le eccezioni generate in un AggregateException, in modo tale che un callback che genera un'eccezione non impedirà l'esecuzione di altri callback registrati.

Anche il nome della variabile è sbagliato perché Annulla viene chiamato CancellationTokenSourcenon sul token stesso e l'origine cambia lo stato di ogni token che gestisce.

Puoi creare un'attività con token di annullamento, quando app vai in background puoi annullare questo token.

Puoi farlo in 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);

Un'altra soluzione è il timer utente in Xamarin.Forms, interrompi il timer quando l'app passa in background https://xamarinhelp.com/xamarin-forms-timer/

È possibile utilizzare ThrowIfCancellationRequestedsenza manipolare l'eccezione!

L'uso di ThrowIfCancellationRequesteddeve essere utilizzato dall'interno di a Task(non a Thread). Quando viene utilizzato all'interno di a Task, non è necessario gestire l'eccezione da soli (e ottenere l'errore Eccezione non gestita). Risulterà in lasciare il Task, e la Task.IsCancelledproprietà sarà True. Non è necessaria la gestione delle eccezioni.

Nel tuo caso specifico, modifica Threadin a Task.

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

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

Devi passare il CancellationTokentoken all'attività, che monitorerà periodicamente il token per vedere se è richiesta la cancellazione.

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(); 

In questo caso, l'operazione terminerà quando verrà richiesta la cancellazione e Taskavrà uno RanToCompletionstato. Se vuoi essere riconosciuto che la tua attività è stata annullata , devi usare ThrowIfCancellationRequestedper lanciare OperationCanceledExceptionun'eccezione.

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(); 

Spero che questo aiuti a capire meglio.