创建一个等待方法执行的 awaitable

Question

我需要做的是等待特定方法被执行。

class MyClass
{
    public void TheMethodToAwait()
    {
        // Do something to signal that the method was invoked
    }

    public AnAwaitableObject TheMethodToAwaitWasExecuted()
    {
        // Need help in creating the awaitable object
    }
}

如您所见，我想要一个返回等待对象的方法，以便其他类可以执行以下操作：

await InstanceOfMyClass.TheMethodToAwaitWasExecuted();

我知道创建自定义等待对象的基础知识，但我一直在努力解决这个问题，因为我从未在实践中这样做过。

像往常一样，非常感谢任何帮助，谢谢

附加信息

该方法需要多次等待。实际上它是游戏主循环中的更新。我的异步方法做了一些必须与循环同步的工作。如果游戏以 60 FPS 运行，那么异步方法需要每秒完成 60 次工作。希望现在这更有意义。

我最后是怎么做到的

为了完整起见，我也会发布我的实现：

public class AwaitableEvent<TResult>
{
    private ConcurrentQueue<EventAwaiter<TResult>> _awaiterQueue;

    public AwaitableEvent()
    {
        _awaiterQueue = new ConcurrentQueue<EventAwaiter<TResult>>();
    }

    public EventAwaiter<TResult> GetAwaiter()
    {
        var awaiter = new EventAwaiter<TResult>();

        _awaiterQueue.Enqueue(awaiter);

        return awaiter;
    }

    public void Notify(TResult result)
    {
        var awaiterCount = _awaiterQueue.Count;

        while (awaiterCount-- > 0)
        {
            EventAwaiter<TResult> awaiter;

            if (_awaiterQueue.TryDequeue(out awaiter))
            {
                awaiter.Notify(result);
            }
        }
    }
}

public class EventAwaiter<TResult> : INotifyCompletion
{
    private Action _continuation;
    private TResult _result;

    public bool IsCompleted
    {
        get { return false; }
    }

    public EventAwaiter()
    {
    }

    public void Notify(TResult result)
    {
        _result = result;

        _continuation();
    }

    public void OnCompleted(Action continuation)
    {
        _continuation = continuation;
    }

    public TResult GetResult()
    {
        return _result;
    }
}

Answer 1

现在我更了解您在做什么，我可以推荐一种我为模拟系统采用的方法。我想要一种编写脚本的方法，可以“等待”下一个模拟更新周期，这非常像游戏循环中的帧。我最初使用的是 TaskCompletionSource，但由于在每次等待时都构建它，所以重载是有问题的。我最终创建了一个这样的自定义等待者：

实现“始终不完整”的可等待对象的简单基类（基本上只是要触发的延续集合）：

public abstract class Awaiter : INotifyCompletion
{
    private readonly List<Action> _continuations = new List<Action>();

    public bool IsCompleted
    {
        get { return false; }
    }

    public abstract void GetResult();

    public void OnCompleted(Action continuation)
    {
        lock (_continuations)
        {
            var syncContext = SynchronizationContext.Current;
            if (syncContext != null)
            {
                _continuations.Add(() => syncContext.Send(s => continuation(), null));
            }
            else
            {
                _continuations.Add(continuation);
            }                
        }
    }

    public void RunContinuations()
    {
        Action[] continuations;
        lock (_continuations)
        {
            continuations = _continuations.ToArray();
            _continuations.Clear();
        }
        foreach (var continuation in continuations)
        {
            continuation();
        }
    }

    public Awaiter GetAwaiter()
    {
        return this;
    }
}

Simulation 类里面是这个（你可以await CycleExecutedEvent() 使用它）：

private readonly CycleExecutedAwaiter _awaiter = new CycleExecutedAwaiter();

        public Awaiter CycleExecutedEvent()
        {
            if (!IsRunning) throw new TaskCanceledException("Simulation has been stopped");
            return _awaiter;
        }

        private sealed class CycleExecutedAwaiter : Awaiter
        {
            public override void GetResult()
            {
                var syncContext = SynchronizationContext.Current as ScriptingSynchronizationContext;
                if (syncContext != null && syncContext.StopRequested)
                    throw new TaskCanceledException("Stop Requested");
            }
        }

希望这与您的用例足够相似以提供帮助。

---

重要提示：

此实现包含一些您可能想要去除的同步上下文技巧。我需要控制用于脚本目的的线程，并且还想阻止我的更新循环，同时给脚本时间执行。您的要求可能会有所不同；例如，您可能希望使用 Task.Run 异步运行延续。不过，这至少应该为如何开始提供一个框架。

Answer 2

如果它只是一个信号（不是可以“设置”然后再“取消设置”和“设置”的东西），那么你可以使用TaskCompletionSource<T>：

class MyClass
{
  private readonly TaskCompletionSource<object> _tcs = new TaskCompletionSource<object>();
  public void TheMethodToAwait()
  {
    _tcs.TrySetResult(null);
  }

  public Task TheMethodToAwaitWasExecutedAsync()
  {
    return _tcs.Task;
  }
}

Answer 3

由于您需要可以“取消设置”和“重置”的内容，因此您真正需要的是asynchronous equivalent of a manual-reset event。你可以建立自己的或use one from my AsyncEx library:

class MyClass
{
  private readonly AsyncManualResetEvent _mre = new AsyncManualResetEvent();

  public void TheMethodToAwait()
  {
    _mre.Set();
  }

  public Task TheMethodToAwaitWasExecutedAsync()
  {
    return _mre.WaitAsync();
  }

  // TODO: some code that calls _mre.Reset()
}