我正在创建一个包含一系列事件的类，其中之一是 GameShuttingDown。触发此事件时，我需要调用事件处理程序。此事件的目的是通知用户游戏正在关闭，他们需要保存数据。保存是可等待的，而事件不是。因此，当处理程序被调用时，游戏会在等待的处理程序完成之前关闭。

public event EventHandler<EventArgs> GameShuttingDown;

public virtual async Task ShutdownGame()
{
    await this.NotifyGameShuttingDown();

    await this.SaveWorlds();

    this.NotifyGameShutDown();
}

private async Task SaveWorlds()
{
    foreach (DefaultWorld world in this.Worlds)
    {
        await this.worldService.SaveWorld(world);
    }
}

protected virtual void NotifyGameShuttingDown()
{
    var handler = this.GameShuttingDown;
    if (handler == null)
    {
        return;
    }

    handler(this, new EventArgs());
}

事件报名

// The game gets shut down before this completes because of the nature of how events work
DefaultGame.GameShuttingDown += async (sender, args) => await this.repo.Save(blah);

我知道事件的签名是void EventName，所以让它异步基本上是即发即忘。我的引擎大量使用事件来通知第 3 方开发人员(和多个内部组件)引擎内正在发生事件并让他们对其使用react。

是否有好的途径可以将事件替换为我可以使用的基于异步的东西？我不确定我是否应该将 BeginShutdownGame 和 EndShutdownGame 与回调一起使用，但这很痛苦，因为只有调用源可以传递回调，而不是任何第 3 方插入引擎的东西，这就是我从事件中得到的。如果服务器调用 game.ShutdownGame()，引擎插件和/或引擎中的其他组件将无法传递它们的回调，除非我连接某种注册方法，保存一个集合回调。

任何关于首选/推荐路线的建议都将不胜感激!我环顾四周，在大多数情况下，我看到的是使用 Begin/End 方法，我认为这不能满足我想要做的事情。

编辑

我正在考虑的另一种选择是使用一种注册方法，它需要一个可等待的回调。我遍历所有回调，获取它们的任务并使用 WhenAll 等待。

private List<Func<Task>> ShutdownCallbacks = new List<Func<Task>>();

public void RegisterShutdownCallback(Func<Task> callback)
{
    this.ShutdownCallbacks.Add(callback);
}

public async Task Shutdown()
{
    var callbackTasks = new List<Task>();
    foreach(var callback in this.ShutdownCallbacks)
    {
        callbackTasks.Add(callback());
    }

    await Task.WhenAll(callbackTasks);
}

最佳答案

就我个人而言，我认为拥有 async 事件处理程序可能不是最佳设计选择，其中最重要的原因就是您遇到的问题。使用同步处理程序，知道它们何时完成是微不足道的。

就是说，如果出于某种原因您必须或至少是强烈被迫坚持这种设计，您可以以await 友好的方式进行。

您注册处理程序并await 的想法是个好主意。但是，我建议坚持使用现有的事件范例，因为这将保持代码中事件的表现力。最主要的是你必须偏离标准的基于 EventHandler 的委托(delegate)类型，并使用返回 Task 的委托(delegate)类型，这样你就可以 await 处理程序。

这里有一个简单的例子来说明我的意思:

class A
{
    public event Func<object, EventArgs, Task> Shutdown;

    public async Task OnShutdown()
    {
        Func<object, EventArgs, Task> handler = Shutdown;

        if (handler == null)
        {
            return;
        }

        Delegate[] invocationList = handler.GetInvocationList();
        Task[] handlerTasks = new Task[invocationList.Length];

        for (int i = 0; i < invocationList.Length; i++)
        {
            handlerTasks[i] = ((Func<object, EventArgs, Task>)invocationList[i])(this, EventArgs.Empty);
        }

        await Task.WhenAll(handlerTasks);
    }
}

OnShutdown() 方法在完成标准的“获取事件委托(delegate)实例的本地副本”之后，首先调用所有处理程序，然后等待所有返回的 Tasks(在调用处理程序时将它们保存到本地数组)。

这是一个简短的控制台程序，说明了其用法:

class Program
{
    static void Main(string[] args)
    {
        A a = new A();

        a.Shutdown += Handler1;
        a.Shutdown += Handler2;
        a.Shutdown += Handler3;

        a.OnShutdown().Wait();
    }

    static async Task Handler1(object sender, EventArgs e)
    {
        Console.WriteLine("Starting shutdown handler #1");
        await Task.Delay(1000);
        Console.WriteLine("Done with shutdown handler #1");
    }

    static async Task Handler2(object sender, EventArgs e)
    {
        Console.WriteLine("Starting shutdown handler #2");
        await Task.Delay(5000);
        Console.WriteLine("Done with shutdown handler #2");
    }

    static async Task Handler3(object sender, EventArgs e)
    {
        Console.WriteLine("Starting shutdown handler #3");
        await Task.Delay(2000);
        Console.WriteLine("Done with shutdown handler #3");
    }
}

看完这个例子后，我现在发现自己想知道 C# 是否有办法对此进行一点抽象。也许这会是一个太复杂的变化，但当前混合了旧式 void-返回事件处理程序和新的 async/await 功能似乎有点尴尬。上面的工作(并且工作得很好，恕我直言)，但是如果有更好的 CLR 和/或语言支持该场景(即能够等待多播委托(delegate)并让 C# 编译器将其转换为对 WhenAll()).

关于c# - 我如何在 C# 中等待事件？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27761852/