Como usar a propriedade CancelamentoToken?

Comparado ao código anterior para a classe RulyCanceler , eu queria executar o código usando CancellationTokenSource.

Como faço para usá-lo conforme mencionado em Tokens de cancelamento , ou seja, sem lançar / capturar uma exceção? Posso usar a IsCancellationRequestedpropriedade?

Tentei usá-lo assim:

cancelToken.ThrowIfCancellationRequested();

e

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

mas isso gerou um erro de tempo de execução cancelToken.ThrowIfCancellationRequested();no método 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:

O código que executei com sucesso capturou a OperationCanceledException no novo 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();
      }
    }
  }
}

Você pode implementar seu método de trabalho da seguinte maneira:

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

É isso aí. Você sempre precisa lidar com o cancelamento sozinho - saia do método quando for o momento apropriado para sair (de modo que seu trabalho e dados estejam em um estado consistente)

ATUALIZAÇÃO: eu prefiro não escrever while (!cancelToken.IsCancellationRequested)porque geralmente existem poucos pontos de saída onde você pode parar a execução com segurança no corpo do loop, e o loop geralmente tem alguma condição lógica para sair (iterar sobre todos os itens da coleção, etc.). Então eu acredito que é melhor não misturar essas condições, pois elas têm intenções diferentes.

Nota de advertência sobre como evitar CancellationToken.ThrowIfCancellationRequested():

Comentário em questão por Eamon Nerbonne :

... substituindo ThrowIfCancellationRequestedcom um monte de cheques para IsCancellationRequestedsaídas normalmente, como diz esta resposta. Mas isso não é apenas um detalhe de implementação; que afeta o comportamento observável: a tarefa não terminará mais no estado cancelado, mas em RanToCompletion. E isso pode afetar não apenas verificações explícitas de estado, mas também, mais sutilmente, o encadeamento de tarefas com ContinueWith, por exemplo , dependendo do TaskContinuationOptionsusado. Eu diria que evitar ThrowIfCancellationRequestedé um conselho perigoso.

@ BrainSlugs83

Você não deve confiar cegamente em tudo postado no stackoverflow. O comentário no código Jens está incorreto, o parâmetro não controla se as exceções são lançadas ou não.

O MSDN é muito claro sobre o que esse parâmetro controla, você leu? http://msdn.microsoft.com/en-us/library/dd321703(v=vs.110).aspx

Se throwOnFirstExceptionfor verdadeiro, uma exceção será propagada imediatamente para fora da chamada para Cancelar, evitando que os retornos de chamada restantes e as operações canceláveis ​​sejam processadas. Se throwOnFirstExceptionfor falso, essa sobrecarga agregará quaisquer exceções lançadas em um AggregateException, de forma que um retorno de chamada que lança uma exceção não evite que outros retornos de chamada registrados sejam executados.

O nome da variável também está errado porque Cancel é chamado CancellationTokenSourcenão no token em si e a origem muda o estado de cada token que gerencia.

Você pode criar uma Tarefa com token de cancelamento, ao aplicar o goto background, você pode cancelar esse token.

Você pode fazer isso em 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);

Outra solução é o Timer do usuário em Xamarin.Forms, pare o cronômetro quando o aplicativo for para o fundo https://xamarinhelp.com/xamarin-forms-timer/

Você pode usar ThrowIfCancellationRequestedsem lidar com a exceção!

O uso de ThrowIfCancellationRequesteddestina-se a ser usado de dentro de a Task(não a Thread). Quando usado em a Task, você não precisa tratar a exceção sozinho (e obter o erro de exceção não tratada). Isso resultará no abandono do Taske a Task.IsCancelledpropriedade será True. Nenhuma manipulação de exceção necessária.

No seu caso específico, altere o Threadpara a Task.

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

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

Você deve passar o CancellationTokenpara a Tarefa, que monitorará periodicamente o token para ver se o cancelamento é solicitado.

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

Nesse caso, a operação será encerrada quando o cancelamento for solicitado e o Taskterá um RanToCompletionestado. Se você quiser ser informado de que sua tarefa foi cancelada , use ThrowIfCancellationRequestedpara lançar uma OperationCanceledExceptionexceção.

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

Espero que isso ajude a entender melhor.