ContinueWith(delegate, CancellationToken) 等价于等待继续

Question

我有这种情况：

private Task LongRunningTask = /* Something */;

private void DoSomethingMore(Task previousTask) { }

public Task IndependentlyCancelableSuccessorTask(CancellationToken cancellationToken)
{
    return LongRunningTask.ContinueWith(DoSomethingMore, cancellationToken);
}

特别是，我在这里感兴趣的行为在MSDN's page about Continuation Tasks 中有以下详细说明：

在这些情况下，延续进入Canceled 状态：

• [...]
• 当延续传递一个System.Threading.CancellationToken 作为参数并且在延续运行之前令牌的IsCancellationRequested 属性是true。在这种情况下，延续不会开始，而是转换到Canceled 状态。

上面的代码有效。但是，我正在将尽可能多的延续转换为使用await 关键字。

是否有使用 await 的等效项，可以在等待的任务完成之前取消继续？

Answer 1

这个答案来自@Servy 来自this answer（有修改）：

public static Task WithCancellation(this Task task,
CancellationToken token)
{
    return task.ContinueWith(t => t.GetAwaiter().GetResult(), token, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
}

public static Task<T> WithCancellation<T>(this Task<T> task,
CancellationToken token)
{
    return task.ContinueWith(t => t.GetAwaiter().GetResult(), token, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
}

Answer 2

我的回答与@Jean Hominal 的回答略有不同，并且也包含了@Noseratio 的方法：

public static class TaskExtensionMethods
{
    public static Task<TResult> OrWhenCancelled<TResult>(this Task<TResult> mainTask, CancellationToken cancellationToken)
    {
        if (!cancellationToken.CanBeCanceled)
            return mainTask;

        return OrWhenCancelled_(mainTask, cancellationToken);
    }

    private static async Task<TResult> OrWhenCancelled_<TResult>(this Task<TResult> mainTask, CancellationToken cancellationToken)
    {
        Task cancellationTask = Task.Delay(Timeout.Infinite, cancellationToken);
        await Task.WhenAny(mainTask, cancellationTask).ConfigureAwait(false);

        cancellationToken.ThrowIfCancellationRequested();
        return await mainTask;
    }

    public static Task OrWhenCancelled(this Task mainTask, CancellationToken cancellationToken)
    {
        if (!cancellationToken.CanBeCanceled)
            return mainTask;

        return OrWhenCancelled_(mainTask, cancellationToken);
    }

    private static async Task OrWhenCancelled_(this Task mainTask, CancellationToken cancellationToken)
    {
        Task cancellationTask = Task.Delay(Timeout.Infinite, cancellationToken);
        await Task.WhenAny(mainTask, cancellationTask).ConfigureAwait(false);
        cancellationToken.ThrowIfCancellationRequested();
        await mainTask;
    }
}

讨论：

• 所有解决方案（包括这个），都没有正确处理原始ContinueWith 指定TaskScheduler 的情况。具体来说，考虑一个为在 UI 场景中使用而创建的 TaskScheduler TaskScheduler.FromCurrentSynchronizationContext。在这种情况下，使用原始的ContinueWith 方法可以保证在运行委托之前但已经进入主线程之后检查取消令牌（请参阅this answer）。也就是说，旧方法具有在考虑任务结果之前在主线程上“最后一次”检查取消标记的良好效果（即胜过主任务是完成还是出错）。这意味着除了使用这些扩展方法之外，新代码还必须将其 await 包装在 try/finally 中，以对 CancellationToken 进行最终检查 :(。参见 this question。

• @Noseratio 的解决方案可以处理上述问题（如果需要），但它的缺点是需要将延续放置到委托中。在我看来，这破坏了转换为使用 await 的一大优势：代码不会以委托结束，它就在 await 之后，并且读起来像普通的顺序代码。

注意事项：

• 我希望我可以指定空 lambda 永远不会运行（即，而不是仅在取消时运行），但 .ContinueWith 方法不允许这样做。所以，我（大多是随意选择了 OnlyOnCancelled）

Answer 3

虽然这个答案在概念上与 Noseratio 的答案相同，但我对实现的一些细节并不满意，因此我发布了我提议的帮助器实现，以便其他人可以就这个问题发表评论。

public static async Task<TResult> WhenNotCanceled<TResult>(this Task<TResult> mainTask, CancellationToken cancellationToken)
{
    if (!cancellationToken.CanBeCanceled) {
        return await mainTask.ConfigureAwait(false);
    }

    cancellationToken.ThrowIfCancellationRequested();

    Task<TResult> completedTask;

    var cancellationTaskSource = new TaskCompletionSource<TResult>();
    using (cancellationToken.Register(() => cancellationTaskSource.TrySetCanceled(), useSynchronizationContext: false)
        completedTask = await Task.WhenAny(mainTask, cancellationTaskSource.Task).ConfigureAwait(false);

    cancellationToken.ThrowIfCancellationRequested();
    return await completedTask.ConfigureAwait(false);
}

public static async Task WhenNotCanceled(this Task mainTask, CancellationToken cancellationToken)
{
    if (!cancellationToken.CanBeCanceled) {
        await mainTask.ConfigureAwait(false);
        return;
    }

    cancellationToken.ThrowIfCancellationRequested();

    Task completedTask;

    var cancellationTaskSource = new TaskCompletionSource<object>();
    using (cancellationToken.Register(() => cancellationTaskSource.TrySetCanceled(), useSynchronizationContext: false)
        completedTask = await Task.WhenAny(mainTask, cancellationTaskSource.Task).ConfigureAwait(false);

    cancellationToken.ThrowIfCancellationRequested();
    await completedTask.ConfigureAwait(false);
}

没有取消的异步模式：

public async Task IndependentlyCancelableSuccessorTask()
{
    await LongRunningTask;
    DoSomethingMore();
}

带有取消和WhenNotCanceled的异步模式：

public async Task IndependentlyCancelableSuccessorTask(CancellationToken cancellationToken)
{
    await LongRunningTask.WhenNotCanceled(cancellationToken);
    DoSomethingMore();
}

Answer 4

下面的应该可以，虽然看起来有点别扭：

private Task LongRunningTask = /* Something */;

private void DoSomethingMore() { }

public async Task IndependentlyCancelableSuccessorTask(
    CancellationToken cancellationToken)
{
    cancellationToken.ThrowIfCancellationRequested();

    var tcs = new TaskCompletionSource<bool>();
    using (cancellationToken.Register(() => tcs.TrySetCanceled()))
        await Task.WhenAny(LongRunningTask, tcs.Task);

    cancellationToken.ThrowIfCancellationRequested();
    DoSomethingMore();
}

[UPDATE] 按照 svick 的建议，这里根据 Stephen Toub 的 Implementing Then with Await 模式将其塑造为助手：

public static class TaskExt
{
    /// <summary>
    /// Use: await LongRunningTask.Then(DoSomethingMore, cancellationToken)
    /// </summary>
    public static async Task Then(
        this Task antecedent, Action continuation, CancellationToken token)
    {
        await antecedent.When(token);
        continuation();
    }

    /// <summary>
    /// Use: await LongRunningTask.When(cancellationToken)
    /// </summary>
    public static async Task When(
        this Task antecedent, CancellationToken token)
    {
        token.ThrowIfCancellationRequested();

        var tcs = new TaskCompletionSource<Empty>();
        using (token.Register(() => tcs.TrySetCanceled()))
            await Task.WhenAny(antecedent, tcs.Task);

        token.ThrowIfCancellationRequested();
    }

    struct Empty { };
}

也许，第一个ThrowIfCancellationRequested() 是多余的，但我没有彻底考虑所有边缘情况。