【异步编程】Part3:取消异步操作

背景

在.Net和C#中运行异步代码相当简单，因为我们有时候需要取消正在进行的异步操作，通过本文，可以掌握通过CancellationToken取消任务（包括non-cancellable任务）。

Task 表示无返回值的异步操作， 泛型版本Task<TResult>表示有返回值的异步操作， 现在async/await 语法糖大大简化了我们编写异步程序的难度。

创建一个长时间运行的操作：

/// <summary>

/// Compute a value for a long time.

/// </summary>

/// <returns>The value computed.</returns>

/// <param name="loop">Number of iterations to do.</param>

private static Task<decimal> LongRunningOperation(int loop)

{

    // Start a task and return it

    return Task.Run(() =>

    {

        decimal result = ;

        // Loop for a defined number of iterations

        for (int i = ; i < loop; i++)

        {

            // Do something that takes times like a Thread.Sleep in .NET Core 2.

            Thread.Sleep();

            result += i;

        }

        return result;

    });

}

// 这里我们使用Thread.Sleep 模仿长时间运行的操作

简单异步调用代码：

public static async Task ExecuteTaskAsync()

{

    Console.WriteLine(nameof(ExecuteTaskAsync));

    Console.WriteLine("Result {0}", await LongRunningOperation());

    Console.WriteLine("Press enter to continue");

    Console.ReadLine();

}

因为一些原因我们会取消异步操作：

操作耗时较长，堵塞了其他正常请求；
不愿意再等待执行结果了，手动取消

编写可取消的异步操作代码

【异步编程】Part3:取消异步操作-LMLPHP

其中关注

类CancellationTokenSource：给CancellationToken发出取消通知

结构体CancellationToken：取消操作的通知。

CancellationToken结构体相当于打入在异步操作内部的楔子，随时等候CancellationTokenSource 发出的取消通知。

【异步编程】Part3:取消异步操作-LMLPHP

【异步编程】Part3:取消异步操作-LMLPHP 定义异步方法时候设定 CancelletionToken参数

那么这个异步方法即是Cancellable 的异步方法

/// <summary>

/// Compute a value for a long time.

/// </summary>

/// <returns>The value computed.</returns>

/// <param name="loop">Number of iterations to do.</param>

/// <param name="cancellationToken">The cancellation token.</param>

private static Task<decimal> LongRunningCancellableOperation(int loop, CancellationToken cancellationToken)

{

    Task<decimal> task = null;

    // Start a task and return it

    task = Task.Run(() =>

    {

        decimal result = ;

        // Loop for a defined number of iterations

        for (int i = ; i < loop; i++)

        {

            // Check if a cancellation is requested, if yes,

            // throw a TaskCanceledException.

            if (cancellationToken.IsCancellationRequested)

                throw new TaskCanceledException(task);

            // Do something that takes times like a Thread.Sleep in .NET Core 2.

            Thread.Sleep();

            result += i;

        }

        return result;

    });

    return task;

}

在长时间运行的操作中监测 IsCancellationRequested方法 (当前是否发生取消命令)，这里我倾向去包装一个TaskCanceledException异常类（给上层方法调用者更多处理的可能性）；当然可以调用ThrowIfCancellationRequested方法抛出OperationCanceledException异常。

发送取消通知

操纵以上CancellationToken状态的对象是 CancellationTokenSource，这个对象是取消操作的命令发布者。

//  定义超时取消

public static async Task ExecuteTaskWithTimeoutAsync(TimeSpan timeSpan)

{

    Console.WriteLine(nameof(ExecuteTaskWithTimeoutAsync));

    using (var cancellationTokenSource = new CancellationTokenSource(timeSpan))

    {

        try

        {

            var result = await LongRunningCancellableOperation(, cancellationTokenSource.Token);

            Console.WriteLine("Result {0}", result);

        }

        catch (TaskCanceledException)

        {

            Console.WriteLine("Task was cancelled");

        }

    }

    Console.WriteLine("Press enter to continue");

    Console.ReadLine();

}

------------------------------------------------------------------------------------------------------------

手动取消操作

public static async Task ExecuteManuallyCancellableTaskAsync()

{

    Console.WriteLine(nameof(ExecuteManuallyCancellableTaskAsync));

    using (var cancellationTokenSource = new CancellationTokenSource())

    {

        // Creating a task to listen to keyboard key press

        var keyBoardTask = Task.Run(() =>

        {

            Console.WriteLine("Press enter to cancel");

            Console.ReadKey();

            // Cancel the task

            cancellationTokenSource.Cancel();

        });

        try

        {

            var longRunningTask = LongRunningCancellableOperation(, cancellationTokenSource.Token);

            var result = await longRunningTask;

            Console.WriteLine("Result {0}", result);

            Console.WriteLine("Press enter to continue");

        }

        catch (TaskCanceledException)

        {

            Console.WriteLine("Task was cancelled");

        }

        await keyBoardTask;

    }

}
// 以上是一个控制台程序，异步接收控制台输入，发出取消命令。

附：取消non-Cancellable任务：

有时候，部分第三方异步操作代码并不是可取消的，也就是以上长时间运行的异步操作LongRunningCancellableOperation(int loop, CancellationToken cancellationToken) 并不支持CancellationToken ，相当于不允许打入楔子。

这时我们怎样取消这样的non-Cancellable 任务？

可考虑利用 Task.WhenAny( params tasks) 操作曲线取消：

利用TaskCompletionSource 注册异步可取消任务
等待待non-cancellable 操作和以上建立的异步取消操作

private static async Task<decimal> LongRunningOperationWithCancellationTokenAsync(int loop, CancellationToken cancellationToken)

{

    // 定义一个任务完成的消息源，任务取消的动作 绑定到该任务完成的动作上

    var taskCompletionSource = new TaskCompletionSource<decimal>();

    cancellationToken.Register(() =>

    {

        taskCompletionSource.TrySetCanceled();

    });

    var task = LongRunningOperation(loop);

    var completedTask = await Task.WhenAny(task, taskCompletionSource.Task);

    return await completedTask;

}

像上面代码一样执行取消命令：

public static async Task CancelANonCancellableTaskAsync()

{

    Console.WriteLine(nameof(CancelANonCancellableTaskAsync));

    using (var cancellationTokenSource = new CancellationTokenSource())

    {

        // Listening to key press to cancel

        var keyBoardTask = Task.Run(() =>

        {

            Console.WriteLine("Press enter to cancel");

            Console.ReadKey();

            // Sending the cancellation message

            cancellationTokenSource.Cancel();

        });

        try

        {

            // Running the long running task

            var longRunningTask = LongRunningOperationWithCancellationTokenAsync(, cancellationTokenSource.Token);

            var result = await longRunningTask;

            Console.WriteLine("Result {0}", result);

            Console.WriteLine("Press enter to continue");

        }

        catch (TaskCanceledException)

        {

            Console.WriteLine("Task was cancelled");

        }

        await keyBoardTask;

    }

}

总结：

大多数情况下，我们不需要编写自定义可取消任务，因为我们只需要使用现有API。但要知道它是如何在幕后工作总是好的。

+ https://johnthiriet.com/cancel-asynchronous-operation-in-csharp/

+ https://stackoverflow.com/questions/4238345/asynchronously-wait-for-taskt-to-complete-with-timeout

+ https://github.com/App-vNext/Polly/wiki/Timeout

取消