我可以有强大的异常安全和事件吗？

Question

假设我有一个方法可以改变一个对象的状态，并触发一个事件来通知监听器这个状态改变：

public class Example
{
   public int Counter { get; private set; }

   public void IncreaseCounter()
   {
      this.Counter = this.Counter + 1;
      OnCounterChanged(EventArgs.Empty);
   }

   protected virtual void OnCounterChanged(EventArgs args)
   {
      if (CounterChanged != null)
         CounterChanged(this,args);
   }

   public event EventHandler CounterChanged;
}

即使IncreaseCounter 成功完成状态更改，事件处理程序也可能抛出异常。所以我们这里没有强大的exception safety：

强有力的保证： 操作已完成 成功或抛出异常， 完全保持程序状态 那是在手术开始之前。

当你需要引发事件时，是否有可能拥有强大的异常安全性？

Answer 1

为了防止处理程序中的异常传播到事件生成器，答案是在 try-catch 内手动调用 MultiCast 委托（即事件处理程序）中的每个项目

所有处理程序都会被调用，异常不会传播。

public EventHandler<EventArgs> SomeEvent;

protected void OnSomeEvent(EventArgs args)
{
    var handler = SomeEvent;
    if (handler != null)
    {
        foreach (EventHandler<EventArgs> item in handler.GetInvocationList())
        {
            try
            {
                item(this, args);
            }
            catch (Exception e)
            {
                // handle / report / ignore exception
            }
        }                
    }
}

剩下的就是让您实现当一个或多个事件接收者抛出而其他事件接收者不抛出时该做什么的逻辑。如果有意义，catch() 也可以捕获特定异常并回滚任何更改，从而允许事件接收者向事件源发出异常情况发生的信号。

正如其他人指出的那样，不建议使用异常作为控制流。如果它确实是一个例外情况，那么一定要使用例外。如果您遇到很多异常，您可能想要使用其他东西。

Answer 2

您将看到的框架的一般模式是：

public class Example
{
   public int Counter { get; private set; }

   public void IncreaseCounter()
   {
      OnCounterChanging(EventArgs.Empty);
      this.Counter = this.Counter + 1;
      OnCounterChanged(EventArgs.Empty);
   }

   protected virtual void OnCounterChanged(EventArgs args)
   {
      if (CounterChanged != null)
         CounterChanged(this, args);
   }

   protected virtual void OnCounterChanging(EventArgs args)
   {
      if (CounterChanging != null)
         CounterChanging(this, args);
   }

   public event EventHandler<EventArgs> CounterChanging;
   public event EventHandler<EventArgs> CounterChanged;
}

如果用户想要抛出异常以防止更改值，那么他们应该在 OnCounterChanging() 事件中而不是在 OnCounterChanged() 中进行。根据名称的定义（过去时，-ed 的后缀）表示值已更改。

编辑：

请注意，您通常希望远离大量额外的 try..catch/finally 块，因为异常处理程序（包括 try..finally）的成本取决于语言实现。即 win32 堆栈框架模型或 PC 映射异常模型都有其优点和缺点，但是如果这些框架太多，它们都会很昂贵（无论是空间还是执行速度）。创建框架时要记住的另一件事。

Answer 3

好吧，如果它很关键，你可以补偿：

public void IncreaseCounter()
{
  int oldCounter = this.Counter;
  try {
      this.Counter = this.Counter + 1;
      OnCounterChanged(EventArgs.Empty);
  } catch {
      this.Counter = oldCounter;
      throw;
  }
}

显然，如果您可以与字段对话，这会更好（因为分配字段不会出错）。你也可以用bolierplate把它包起来：

void SetField<T>(ref T field, T value, EventHandler handler) {
    T oldValue = field;
    try {
         field = value;
         if(handler != null) handler(this, EventArgs.Empty);
    } catch {
         field = oldField;
         throw;
    }
}

然后调用：

SetField(ref counter, counter + 1, CounterChanged);

或类似的东西......

Answer 4

在这种情况下，我认为您应该从 Workflow Foundation 中获得启发。在 OnCounterChanged 方法中，使用通用 try-catch 块围绕对委托的调用。在 catch 处理程序中，您必须执行有效的补偿操作 - 回滚计数器。

Answer 5

不会简单地交换 IncreaseCounter 中两行的顺序为您实施强大的异常安全吗？

或者如果您需要在引发事件之前增加Counter：

public void IncreaseCounter()
{
    this.Counter += 1;

    try
    {
        OnCounterChanged(EventArgs.Empty);
    }
    catch
    {
        this.Counter -= 1;

        throw;
    }
}

在您有更复杂的状态更改（副作用）的情况下，它会变得相当复杂（例如，您可能必须克隆某些对象），但在本示例中，这似乎很容易。