Làm thế nào để hủy bỏ một nhiệm vụ đang chờ?

Tôi đang chơi với các tác vụ WinRT Windows 8 này và tôi đang cố gắng hủy tác vụ bằng phương pháp bên dưới và nó hoạt động đến một lúc nào đó. Phương thức Hủy bỏ thông báo KHÔNG được gọi, khiến bạn nghĩ rằng tác vụ đã bị hủy, nhưng trong nền, tác vụ vẫn tiếp tục chạy, sau khi hoàn thành, trạng thái của Tác vụ luôn hoàn thành và không bao giờ bị hủy. Có cách nào để dừng hoàn toàn nhiệm vụ khi nó bị hủy không?

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

Đọc về Hủy bỏ (được giới thiệu trong .NET 4.0 và phần lớn không thay đổi kể từ đó) và Mẫu không đồng bộ dựa trên nhiệm vụ , cung cấp hướng dẫn về cách sử dụng CancellationTokenvới asynccác phương thức.

Để tóm tắt, bạn chuyển một CancellationTokenvào từng phương thức hỗ trợ hủy bỏ và phương thức đó phải kiểm tra định kỳ.

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

Hoặc, để tránh sửa đổi slowFunc(ví dụ: bạn không có quyền truy cập vào mã nguồn):

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

Bạn cũng có thể sử dụng các phương thức tiện ích mở rộng đẹp từ https://github.com/StephenCleary/AsyncEx và có giao diện đơn giản như sau:

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

Một trường hợp chưa được đề cập là cách xử lý hủy bên trong phương thức không đồng bộ. Lấy ví dụ một trường hợp đơn giản trong đó bạn cần tải một số dữ liệu lên một dịch vụ để lấy nó để tính toán một cái gì đó và sau đó trả về một số kết quả.

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

Nếu bạn muốn hỗ trợ hủy thì cách dễ nhất là chuyển mã thông báo và kiểm tra xem nó có bị hủy giữa mỗi lần gọi phương thức không đồng bộ không (hoặc sử dụng ContinWith). Nếu chúng là các cuộc gọi chạy rất lâu mặc dù bạn có thể đợi một lúc để hủy. Tôi đã tạo ra một phương thức trợ giúp nhỏ để thay vì thất bại ngay khi hủy bỏ.

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

Vì vậy, để sử dụng nó, sau đó chỉ cần thêm .WaitOrCancel(token)vào bất kỳ cuộc gọi async nào:

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

Lưu ý rằng điều này sẽ không dừng Nhiệm vụ mà bạn đang chờ và nó sẽ tiếp tục chạy. Bạn sẽ cần sử dụng một cơ chế khác để ngăn chặn nó, chẳng hạn như CancelAsynccuộc gọi trong ví dụ hoặc tốt hơn là chuyển qua cùng CancellationTokenđể Taskcó thể xử lý hủy cuối cùng. Cố gắng hủy bỏ chủ đề không được khuyến khích .

Tôi chỉ muốn thêm vào câu trả lời đã được chấp nhận. Tôi đã bị mắc kẹt trong vấn đề này, nhưng tôi đã đi một con đường khác để xử lý sự kiện hoàn chỉnh. Thay vì chạy chờ, tôi thêm một trình xử lý đã hoàn thành vào nhiệm vụ.

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

Trường hợp xử lý sự kiện trông như thế này

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

Với tuyến đường này, tất cả việc xử lý đã được thực hiện cho bạn, khi tác vụ bị hủy, nó chỉ kích hoạt trình xử lý sự kiện và bạn có thể xem liệu nó có bị hủy ở đó không.