将回调包装到异步任务中

Question

我无法控制来自 API 的以下方法。

public void Start(Action OnReady);

总的来说，我对回调很好，但有时你有触发回调的回调等等。因此，我想将它包装到异步方法中，并且可能还包括取消操作的可能性。像这样的：

await Start(cancellationToken);

这是我想出的：

public Task Start(CancellationToken cancellationToken)
{
     return Task.Run(() =>
     {
           cancellationToken.ThrowIfCancellationRequested();

           var readyWait = new AutoResetEvent(false);

           cancellationToken.Register(() => readyWait?.Set());

           Start(() => { readyWait.Set(); }); //this is the API method

           readyWait.WaitOne();
           readyWait.Dispose();
           readyWait = null;

           if(cancellationToken.IsCancellationRequested)
           {
                APIAbort(); //stop the API Start method from continuing
                cancellationToken.ThrowIfCancellationRequested();
            }

      }, cancellationToken);
}

我认为还有改进的余地，但我想到的一件事是这种方法在这种情况下有什么作用？

readyWait.WaitOne(); 

我想编写一个异步方法来不阻塞任何线程，但这正是 WaitOne 所做的。当然它不会因为任务而阻塞调用线程，但是任务是否获得了自己的线程？如果只有任务会被阻止我会很好，但我不想阻止可能在其他地方使用的线程。

Answer 1

public Task StartAsync(CancellationToken c)
{
    var cs = new TaskCompletionSource<bool>();

    c.Register(() => { Abort(); cs.SetCanceled(); } );
    Start(() => { cs.SetResult(true); });

    return cs.Task;
}

using (var ct = new CancellationTokenSource(1000))
{
    try
    {
        await StartAsync(ct.Token);

        MessageBox.Show("Completed");
    }
    catch (TaskCanceledException)
    {
        MessageBox.Show("Cancelled");
    }
}

没有必要使用取消标记，因为它可以触发的唯一点是在方法被调用之后和完成之前，此时它是一个竞争条件。

Answer 2

这个问题出奇的棘手。案子很多，每个案子的处理并不总是一目了然。

很明显：

1. Start 方法可能需要很长时间才能完成。 APIAbort 方法也是如此。
2. CancellationToken 可以在 Start 方法之前、期间或之后取消，甚至在 OnReady 回调调用之后。
3. 不应在Start 之前或期间，或在OnReady 回调调用之后调用APIAbort。
4. 即使在 Start 方法完成之前发生取消，也应该调用 APIAbort。

不明显：

1. 返回的Task 应该在APIAbort 调用之前还是之后完成为取消？
2. 如果APIAbort 抛出异常怎么办？如果返回的Task 已被取消，如何传播此异常？
3. 如果Start 抛出OperationCanceledException 异常怎么办？这是故障还是取消？

下面的实现在调用APIAbort 方法之前取消Task，抑制APIAbort 期间可能发生的异常，并处理 OperationCanceledException 在Start 期间取消。

public Task StartAsync(CancellationToken cancellationToken)
{
    if (cancellationToken.IsCancellationRequested)
        return Task.FromCanceled(cancellationToken);

    var tcs = new TaskCompletionSource<bool>();

    var cancellationRegistration = cancellationToken.Register(() =>
        tcs.TrySetCanceled(cancellationToken));

    var fireAndForget = Task.Run(() =>
    {
        if (cancellationToken.IsCancellationRequested) return;
        try
        {
            Start(() =>
            {
                cancellationRegistration.Dispose(); // Unregister
                tcs.TrySetResult(true);
            });
        }
        catch (OperationCanceledException)
        {
            tcs.TrySetCanceled();
            return;
        }
        catch (Exception ex)
        {
            tcs.TrySetException(ex);
            return;
        }

        // At this point Start is completed succesfully. Calling APIAbort is allowed.
        var continuation = tcs.Task.ContinueWith(_ =>
        {
            try
            {
                APIAbort();
            }
            catch { } // Suppressed
        },  default, TaskContinuationOptions.OnlyOnCanceled
        | TaskContinuationOptions.RunContinuationsAsynchronously,
        TaskScheduler.Default);
    }, cancellationToken);

    return tcs.Task;
}

设置选项TaskContinuationOptions.RunContinuationsAsynchronously的原因是为了避免APIAbort与await StartAsync()之后的代码同步运行（在同一个线程中）的可能性。当我使用async-await 作为延续机制时，我最初运行到this problem。

Answer 3

我想把它包装成一个异步方法，也许还包括取消操作的可能性。

我建议将它们分开。原因是您的“取消”实际上并没有取消Start。它只会取消 wait 以等待 Start 完成。所以在这个级别取消会产生误导。

您可以使用与pattern for wrapping an event into a Task 类似的方法将委托回调包装到Task：

public static Task StartAsync(this ApiObject self)
{
  var tcs = new TaskCompletionSource<object>();
  self.Start(() => tcs.SetResult(null));
  return tcs.Task;
}

现在您可以拨打StartAsync 并取回Task，如果您愿意，可以选择不继续等待：

var startTask = apiObject.StartAsync();
var timeoutTask = Task.Delay(TimeSpan.FromSeconds(10));
var completedTask = await Task.WhenAny(startTask, timeoutTask);
if (completedTask == timeoutTask)
  return;