Como cancelar uma tarefa em espera?

Estou brincando com essas tarefas do Windows 8 WinRT e estou tentando cancelar uma tarefa usando o método abaixo e funciona até certo ponto. O método CancelNotification é chamado, o que faz você pensar que a tarefa foi cancelada, mas, em segundo plano, a tarefa continua sendo executada; depois de concluída, o status da tarefa é sempre concluído e nunca é cancelado. Existe uma maneira de interromper completamente a tarefa quando ela é cancelada?

private async void TryTask()
{
    CancellationTokenSource source = new CancellationTokenSource();
    source.Token.Register(CancelNotification);
    source.CancelAfter(TimeSpan.FromSeconds(1));
    var task = Task<int>.Factory.StartNew(() => slowFunc(1, 2), source.Token);

    await task;            

    if (task.IsCompleted)
    {
        MessageDialog md = new MessageDialog(task.Result.ToString());
        await md.ShowAsync();
    }
    else
    {
        MessageDialog md = new MessageDialog("Uncompleted");
        await md.ShowAsync();
    }
}

private int slowFunc(int a, int b)
{
    string someString = string.Empty;
    for (int i = 0; i < 200000; i++)
    {
        someString += "a";
    }

    return a + b;
}

private void CancelNotification()
{
}

Leia-se sobre cancelamento (que foi introduzido no .NET 4.0 e é em grande parte inalterado desde então) eo padrão assíncrono baseado em tarefas , que fornece orientações sobre como usar CancellationTokencom asyncmétodos.

Para resumir, você passa um CancellationTokenpara cada método que suporta cancelamento, e esse método deve verificá-lo periodicamente.

private async Task TryTask()
{
  CancellationTokenSource source = new CancellationTokenSource();
  source.CancelAfter(TimeSpan.FromSeconds(1));
  Task<int> task = Task.Run(() => slowFunc(1, 2, source.Token), source.Token);

  // (A canceled task will raise an exception when awaited).
  await task;
}

private int slowFunc(int a, int b, CancellationToken cancellationToken)
{
  string someString = string.Empty;
  for (int i = 0; i < 200000; i++)
  {
    someString += "a";
    if (i % 1000 == 0)
      cancellationToken.ThrowIfCancellationRequested();
  }

  return a + b;
}

Ou, para evitar modificações slowFunc(digamos que você não tenha acesso ao código fonte, por exemplo):

var source = new CancellationTokenSource(); //original code
source.Token.Register(CancelNotification); //original code
source.CancelAfter(TimeSpan.FromSeconds(1)); //original code
var completionSource = new TaskCompletionSource<object>(); //New code
source.Token.Register(() => completionSource.TrySetCanceled()); //New code
var task = Task<int>.Factory.StartNew(() => slowFunc(1, 2), source.Token); //original code

//original code: await task;  
await Task.WhenAny(task, completionSource.Task); //New code

Você também pode usar bons métodos de extensão em https://github.com/StephenCleary/AsyncEx e parecer simples como:

await Task.WhenAny(task, source.Token.AsTask());

Um caso que não foi coberto é como lidar com o cancelamento dentro de um método assíncrono. Tomemos, por exemplo, um caso simples em que você precise enviar alguns dados para um serviço, obtê-lo para calcular algo e retornar alguns resultados.

public async Task<Results> ProcessDataAsync(MyData data)
{
    var client = await GetClientAsync();
    await client.UploadDataAsync(data);
    await client.CalculateAsync();
    return await client.GetResultsAsync();
}

Se você deseja dar suporte ao cancelamento, a maneira mais fácil seria passar um token e verificar se ele foi cancelado entre cada chamada de método assíncrona (ou usando ContinueWith). Se as chamadas forem muito longas, você poderá esperar um pouco para cancelar. Eu criei um pequeno método auxiliar para falhar assim que cancelado.

public static class TaskExtensions
{
    public static async Task<T> WaitOrCancel<T>(this Task<T> task, CancellationToken token)
    {
        token.ThrowIfCancellationRequested();
        await Task.WhenAny(task, token.WhenCanceled());
        token.ThrowIfCancellationRequested();

        return await task;
    }

    public static Task WhenCanceled(this CancellationToken cancellationToken)
    {
        var tcs = new TaskCompletionSource<bool>();
        cancellationToken.Register(s => ((TaskCompletionSource<bool>)s).SetResult(true), tcs);
        return tcs.Task;
    }
}

Então, para usá-lo, basta adicionar .WaitOrCancel(token)a qualquer chamada assíncrona:

public async Task<Results> ProcessDataAsync(MyData data, CancellationToken token)
{
    Client client;
    try
    {
        client = await GetClientAsync().WaitOrCancel(token);
        await client.UploadDataAsync(data).WaitOrCancel(token);
        await client.CalculateAsync().WaitOrCancel(token);
        return await client.GetResultsAsync().WaitOrCancel(token);
    }
    catch (OperationCanceledException)
    {
        if (client != null)
            await client.CancelAsync();
        throw;
    }
}

Observe que isso não interromperá a tarefa que você estava esperando e continuará sendo executada. Você precisará usar um mecanismo diferente para interrompê-lo, como a CancelAsyncchamada no exemplo, ou, melhor ainda, passar o mesmo CancellationTokenpara Taskque ele possa lidar com o cancelamento eventualmente. Não é recomendável tentar abortar o thread .

Eu só quero adicionar à resposta já aceita. Eu estava preso nisso, mas estava seguindo um caminho diferente ao lidar com o evento completo. Em vez de aguardar, adiciono um manipulador completo à tarefa.

Comments.AsAsyncAction().Completed += new AsyncActionCompletedHandler(CommentLoadComplete);

Onde o manipulador de eventos se parece com isso

private void CommentLoadComplete(IAsyncAction sender, AsyncStatus status )
{
    if (status == AsyncStatus.Canceled)
    {
        return;
    }
    CommentsItemsControl.ItemsSource = Comments.Result;
    CommentScrollViewer.ScrollToVerticalOffset(0);
    CommentScrollViewer.Visibility = Visibility.Visible;
    CommentProgressRing.Visibility = Visibility.Collapsed;
}

Com essa rota, todo o tratamento já está feito para você, quando a tarefa é cancelada, apenas aciona o manipulador de eventos e você pode ver se foi cancelado lá.