如何在 C# 中实现取消共享任务：s

Question

所有，这里有一个关于在 C# 中取消 Task:s 的复杂案例的设计/最佳实践的问题。如何实现共享任务的取消？

作为一个最小的例子，让我们假设以下内容；我们有一个长期运行的、可合作取消的操作“工作”。它接受一个取消标记作为参数，如果它被取消则抛出。它对某些应用程序状态进行操作并返回一个值。它的结果是两个 UI 组件独立需要的。

在应用程序状态不变的情况下，应缓存 Work 函数的值，如果正在进行一次计算，则新请求不应开始第二次计算，而是开始等待结果。

任何一个 UI 组件都应该能够取消它的任务，而不会影响其他 UI 组件的任务。

到目前为止，你和我在一起吗？

上述可以通过引入一个Task缓存来完成，该缓存将真正的Work任务包装在TaskCompletionSources中，然后将其Task:s返回给UI组件。如果 UI 组件取消它的任务，它只会放弃 TaskCompletionSource 任务，而不是底层任务。这一切都很好。 UI 组件创建 CancellationSource 和取消请求是一个正常的自上而下的设计，与底部的协作 TaskCompletionSource 任务。

现在，解决真正的问题。应用状态发生变化时怎么办？让我们假设让“工作”函数对状态副本进行操作是不可行的。

一种解决方案是监听任务缓存（或附近）中的状态变化。如果缓存有底层任务使用的 CancellationToken，即运行 Work 函数的任务，它可以取消它。这可能会触发所有附加的 TaskCompletionSources Task:s 的取消，因此两个 UI 组件都将获得 Canceled 任务。这是某种自下而上的取消。

有没有首选的方法来做到这一点？是否有一种设计模式可以在某处描述它？

自下而上的取消是可以实现的，但是感觉有点怪。 UI 任务是使用 CancellationToken 创建的，但由于另一个（内部）CancellationToken 而被取消。此外，由于令牌不相同，因此不能仅在 UI 中忽略 OperationCancelledException - 这将（最终）导致在外部 Task:s 终结器中引发异常。

Answer 1

听起来你想要一组贪婪的任务操作——你有一个任务结果提供者，然后构造一个任务集来返回第一个完成的操作，例如：

// Task Provider - basically, construct your first call as appropriate, and then 
//   invoke this on state change

public void OnStateChanged()
{
    if(_cts != null)
       _cts.Cancel();

    _cts = new CancellationTokenSource();
    _task = Task.Factory.StartNew(() =>
       {
           // Do Computation, checking for cts.IsCancellationRequested, etc
           return result;
       });
}

// Consumer 1

var cts = new CancellationTokenSource();
var task = Task.Factory.StartNew(() =>
  {
       var waitForResultTask = Task.Factory.StartNew(() =>
          {
              // Internally, this is invoking the task and waiting for it's value
              return MyApplicationState.GetComputedValue();
          });

       // Note this task cares about being cancelled, not the one above
       var cancelWaitTask = Task.Factory.StartNew(() =>
         {
              while(!cts.IsCancellationRequested)
                 Thread.Sleep(25);

              return someDummyValue;
         });

       Task.WaitAny(waitForResultTask, cancelWaitTask);

       if(cancelWaitTask.IsComplete)
          return "Blah"; // I cancelled waiting on the original task, even though it is still waiting for it's response
       else
          return waitForResultTask.Result;
  });

现在，我尚未对此进行全面测试，但它应该允许您通过取消令牌来“取消”等待任务（从而强制“等待”任务首先完成并点击WaitAny），并允许您“取消”计算任务。

另一件事是找出一种让“取消”任务等待而不会出现可怕阻塞的干净方法。我认为这是一个好的开始。

Answer 2

这是我的尝试：

// the Task for the current application state
Task<Result> _task;
// a CancellationTokenSource for the current application state
CancellationTokenSource _cts;

// called when the application state changes
void OnStateChange()
{
    // cancel the Task for the old application state
    if (_cts != null)
    {
        _cts.Cancel();
    }

    // new CancellationTokenSource for the new application state
    _cts = new CancellationTokenSource();
    // start the Task for the new application state
    _task = Task.Factory.StartNew<Result>(() => { ... }, _cts.Token);
}

// called by UI component
Task<Result> ComputeResultAsync(CancellationToken cancellationToken)
{
    var task = _task;
    if (cancellationToken.CanBeCanceled && !task.IsCompleted)
    {
        task = WrapTaskForCancellation(cancellationToken, task);
    }
    return task;
}

与

static Task<T> WrapTaskForCancellation<T>(
    CancellationToken cancellationToken, Task<T> task)
{
    var tcs = new TaskCompletionSource<T>();
    if (cancellationToken.IsCancellationRequested)
    {
        tcs.TrySetCanceled();
    }
    else
    {
        cancellationToken.Register(() =>
        {
            tcs.TrySetCanceled();
        });
        task.ContinueWith(antecedent =>
        {
            if (antecedent.IsFaulted)
            {
                tcs.TrySetException(antecedent.Exception.GetBaseException());
            }
            else if (antecedent.IsCanceled)
            {
                tcs.TrySetCanceled();
            }
            else
            {
                tcs.TrySetResult(antecedent.Result);
            }
        }, TaskContinuationOptions.ExecuteSynchronously);
    }
    return tcs.Task;
}