可取消的“一劳永逸”任务。这是不好的做法吗？我的实现是否正确？

Question

背景：我正在开发一个应用程序，它本质上是一个用于远程服务器的缓存文件浏览器。当用户单击一个目录时，它将从目录树的本地副本中向他们显示其子目录。然后它还会启动一个“即发即弃”任务，以从服务器检索对视图中目录的更改，并更新缓存和用户正在显示的内容。

private CancellationTokenSource _cts;
private SemaphoreSlim _myTaskBlocker = new SemaphoreSlim(1,1);

public void CancelMyTask()
{
    _cts?.Cancel();
}

public async Task FireAndForgetWithCancel()
{
    await _myTaskBlocker.WaitAsync();
    _cts = new CancellationTokenSource();

    try
    {
        //Some potentially long running code.
        token.ThrowIfCancellationRequested();
    }
    catch(OperationCancelledException){}
    finally
    {        
        _cts.dispose();
        _cts = null;
        _myTaskBlocker.Release();
    }
}

编辑 1：可以这样做吗？ SemaphoreSlim 有点像 _cts 上的锁定，所以我不需要在进行更改之前锁定它吗？

编辑 2：所以我得出的结论是，这是一个坏主意，并且无法以我最初希望的方式真正实现。

我的解决方案是让 ViewModel 发送请求并监听更新事件。

  public class Model
    {
        // Thread safe observable collection with AddRange.
        public ObservableCollectionEx<file> Files { get; }

        // A request queue.
        public ActionBlock<request> Requests { get; }
    }

    public class ViewModel
    {
        public ObservableCollectionEx<file> FilesTheUserSees { get; }

        public ViewModel()
        {
            Model.Files.CollectionChanged += FileCollectionChanged;
        }

        public async Task UserInstigatedEvent()
        {
            // Do some stuff to FilesTheUserSees here.

            // Request the model to check for updates. Blocks only as long as it takes to send the message.
            await Model.Requests.SendAsync(new request());
        }

        public void FileCollectionChanged(object sender, CollectionChangedEventArgs e)
        {
            // Check to see if there are any new files in Files.
            // If there are new files that match the current requirements add them to FilesTheUserSees.
        }
    }

需要注意的一些问题是，现在依赖 ObservableCollectionsEx 来实现线程安全，但这是一个可以实现的目标，并且即使它有一些缺点也更容易调试。

Answer 1

这不是对CancellationToken 取消过程的良好使用。您的代码有几个正确使用取消令牌不会遇到的问题：

1. CancelMyTask 和 FireAndForgetWithCancel 是相互依赖的，因为它们在内部与 CancellationTokenSource 连接，FireAndForgetWithCancel 创建 和 销毁，但 CancelMyTask 使用。当CancelMyTask 起作用时，您只有一个小窗口，而当取消起作用时，您没有直接指示。
2. 如果您多次调用FireAndForgetWithCancel，CancelMyTask 只会取消最后一个任务，而其他任务会继续执行。
3. 由于FireAndForgetWithCancel 创建了自己的CancellationTokenSource 并为自己保留了CancellationToken，因此其他消费者无法使用该令牌，例如触发自己的取消或将其与其他令牌组合。
4. 在FireAndForgetWithCancel 中，您抓住OperationCancelledException 而不是让它通过。这意味着任务永远不会处于取消状态。

正确的用法是接受取消令牌作为参数，让调用者处理取消，建议将CancellationTokenSource和CancellationToken分开：

private SemaphoreSlim _myTaskBlocker = new SemaphoreSlim(1,1);

public async Task FireAndForgetWithCancel(CancellationToken cancellationToken)
{
    await _myTaskBlocker.WaitAsync();

    try
    {
        //Some potentially long running code.
        cancellationToken.ThrowIfCancellationRequested();
    }
    finally
    {        
        _myTaskBlocker.Release();
    }
}

调用者将创建一个CancellationTokenSource 以获取取消令牌，或者将通过现有的令牌。这将完全取决于调用者，最好留给它。