Bagaimana cara membatalkan Tugas dalam menunggu?

Saya bermain dengan tugas-tugas Windows 8 WinRT ini, dan saya mencoba untuk membatalkan tugas menggunakan metode di bawah ini, dan itu berfungsi sampai titik tertentu. Metode CancelNotification TIDAK dipanggil, yang membuat Anda berpikir tugas itu dibatalkan, tetapi di latar belakang tugas itu terus berjalan, kemudian setelah selesai, status Tugas selalu selesai dan tidak pernah dibatalkan. Apakah ada cara untuk benar-benar menghentikan tugas saat dibatalkan?

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()
{
}

Baca di Pembatalan (yang diperkenalkan di NET 4.0 dan sebagian besar tidak berubah sejak saat itu) dan Pola Asynchronous Task-Based , yang menyediakan panduan tentang bagaimana menggunakan CancellationTokendengan asyncmetode.

Untuk meringkas, Anda meneruskan CancellationTokenke setiap metode yang mendukung pembatalan, dan metode itu harus memeriksanya secara berkala.

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;
}

Atau, untuk menghindari modifikasi slowFunc(misalnya Anda tidak memiliki akses ke kode sumber):

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

Anda juga dapat menggunakan metode ekstensi yang bagus dari https://github.com/StephenCleary/AsyncEx dan membuatnya terlihat sesederhana:

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

Satu kasus yang belum dibahas adalah bagaimana menangani pembatalan di dalam metode async. Ambil contoh kasus sederhana di mana Anda perlu mengunggah beberapa data ke layanan untuk menghitung sesuatu dan kemudian mengembalikan beberapa hasil.

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

Jika Anda ingin mendukung pembatalan, maka cara termudah adalah dengan memberikan token dan memeriksa apakah telah dibatalkan di antara setiap pemanggilan metode async (atau menggunakan ContinueWith). Jika panggilannya sangat lama, Anda bisa menunggu beberapa saat untuk membatalkan. Saya membuat metode pembantu kecil sebagai gantinya gagal segera setelah dibatalkan.

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;
    }
}

Jadi untuk menggunakannya, tambahkan saja .WaitOrCancel(token)ke panggilan async:

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;
    }
}

Perhatikan bahwa ini tidak akan menghentikan Tugas yang Anda tunggu dan itu akan terus berjalan. Anda harus menggunakan mekanisme yang berbeda untuk menghentikannya, seperti CancelAsyncpanggilan dalam contoh, atau lebih baik lagi lulus dalam yang sama CancellationTokendengan Tasksehingga dapat menangani pembatalan akhirnya. Mencoba untuk membatalkan utas tidak disarankan .

Saya hanya ingin menambahkan jawaban yang sudah diterima. Saya terjebak dalam hal ini, tetapi saya mengambil rute yang berbeda dalam menangani acara lengkap. Daripada menjalankan menunggu, saya menambahkan penangan yang selesai untuk tugas.

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

Di mana event handler terlihat seperti ini

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;
}

Dengan rute ini, semua penanganan sudah dilakukan untuk Anda, ketika tugas dibatalkan itu hanya memicu pengendali acara dan Anda dapat melihat apakah itu dibatalkan di sana.