将遗留ISomeService事件通过IProgress<T>上报的实现方案是否存在风险？

这个方案看起来逻辑通顺，但实际运行中会遇到几个关键问题，尤其是涉及异步场景的时候：

• 异步触发的事件会被错过
  你的代码里同步调用_someService.MakeSomethingHappen()后，立刻在finally块中取消了事件订阅。但如果MakeSomethingHappen内部是异步执行逻辑（比如启动后台线程、用Task.Run包裹耗时操作），方法会立即返回，finally块会马上移除事件处理程序——这时候后续触发的SomethingHappened事件就完全捕获不到了。

  举个典型的反例：

  public void MakeSomethingHappen()
  {
      // 模拟异步逻辑：后台线程延迟触发事件
      Task.Run(() => 
      {
          Thread.Sleep(1000);
          SomethingHappened?.Invoke(this, new SomeEventArgs());
      });
  }
  

  你的代码会在调用MakeSomethingHappen后一秒内就取消订阅，完全接收不到延迟触发的事件。

• async方法没有await，违背异步语义
  你把DoSomethingElse标记为async Task，但方法内部没有任何await操作。这会导致两个问题：

  1. 编译器会抛出警告，提示你这个异步方法实际上是同步执行的；
  2. 调用方用await DoSomethingElse(...)时，会误以为在等待异步操作完成，但实际方法会同步跑完所有逻辑后立即返回完成状态，完全不符合异步方法的预期行为。

• 极端场景下的竞态条件
  虽然.NET中事件的+=和-=是原子操作，但如果SomethingHappened事件刚好在取消订阅的瞬间被触发，会出现竞态条件：事件触发时委托列表已经开始遍历，此时你的处理程序被移除，可能导致事件处理程序被调用一次或者完全不被调用，行为不确定。这个问题发生概率低，但也是需要注意的潜在风险。

1. 确保等待所有操作完成后再取消订阅 #

如果能修改遗留的ISomeService接口，最好把MakeSomethingHappen改为异步方法，然后在DoSomethingElse中await它，这样finally块会在异步操作完全结束后才执行，保证所有事件都被捕获：

public async Task DoSomethingElse(IProgress<SomeEventArgs> progress)
{
    void handleEvent(object sender, SomeEventArgs e)
    {
        progress?.Report(e);
    }

    _someService.SomethingHappened += handleEvent;
    try
    {
        await _someService.MakeSomethingHappenAsync(); // 等待异步操作完成
    }
    finally
    {
        _someService.SomethingHappened -= handleEvent;
    }
}

如果无法修改接口，那必须确保MakeSomethingHappen内部的所有逻辑都是同步执行的（即调用后会阻塞到所有事件触发完成），否则只能用同步原语（比如ManualResetEventSlim）手动等待事件触发完成，但这种方式比较hack，不推荐在生产环境使用。

2. 修复async方法的语义问题 #

如果MakeSomethingHappen是纯同步逻辑，你可以直接移除async标记，返回Task.CompletedTask：

public Task DoSomethingElse(IProgress<SomeEventArgs> progress)
{
    void handleEvent(object sender, SomeEventArgs e)
    {
        progress?.Report(e);
    }

    _someService.SomethingHappened += handleEvent;
    try
    {
        _someService.MakeSomethingHappen();
    }
    finally
    {
        _someService.SomethingHappened -= handleEvent;
    }
    return Task.CompletedTask;
}

如果必须保持方法为异步，可以添加await Task.Yield()来强制切换上下文，让调用方可以继续执行：

public async Task DoSomethingElse(IProgress<SomeEventArgs> progress)
{
    void handleEvent(object sender, SomeEventArgs e)
    {
        progress?.Report(e);
    }

    _someService.SomethingHappened += handleEvent;
    try
    {
        _someService.MakeSomethingHappen();
        await Task.Yield(); // 切换上下文，让方法真正异步
    }
    finally
    {
        _someService.SomethingHappened -= handleEvent;
    }
}

3. 可选：考虑弱事件模式防止内存泄漏 #

如果_someService是长生命周期对象（比如单例），而OtherService是短暂创建的实例，直接订阅事件可能导致OtherService无法被GC回收，引发内存泄漏。这种情况下可以使用.NET的弱事件模式（比如WeakEventManager）来避免这个问题，但这属于进阶优化，需要根据你的实际场景判断是否必要。

内容的提问来源于stack exchange，提问作者vladek