如何处理多个操作和异常

Question

我想知道以下问题是否有例外的解决方案：

下面我有 SomeClass ，它有一个可以执行多个操作（命令）的成员函数。各个动作由另一个成员函数执行，该成员函数始终使对象处于良好且可预测的状态。

问题是如何处理某些操作执行没有错误，然后某个操作导致异常的情况。现在应该做什么。

我看到了这些解决方案，但感觉都不好：

a) 将异常传递给“ExecuteMultipleCommands”的调用者。这使对象处于良好但不可预测的状态（不知道执行了哪些操作）。

b) 失败后继续执行命令。如果命令不独立，这就是一个问题，而且很难知道要返回给调用者什么。

c) 在第一个异常处，尝试恢复已完成的操作，以便对象返回到调用“ExecuteMultipleCommands”之前的状态。现在“回滚”期间可能会发生另一个异常。

下面的代码不是真正的代码，但应该显示我的问题：

class SomeClass
{
  public:
  struct Command
  {
    /*...*/
  };

  void ExecuteOneCommand( const Command &oneCommand )
  {
      /* either completely executes a command or throws exception and leave object in unchanged state */
  }

  void ExecuteMultipleCommands( const vector< Command > &commands )
  {
      vector< Command >::const_iterator it = commands.begin();
      for ( ; it != commands.end(); ++it )
      {
          try
          {
              ExecuteOneCommand( *it );
          }
          catch( /* some exception type */ )
          {
              /* what to do ? */
          }
      }
  }
};

是否有关于此问题或其他出版物的设计模式？我已经搜索过，但几乎是空的。

注意：该代码是实际问题的简化版本。在实际代码中，SomeClass 实例持有的多个对象将在命令期间发生变化。这将使使用 SomeClass 实例的副本变得更加困难，并且在没有发生异常的情况下将其替换为原始实例。

此外，命令可以取决于对象的当前状态。就像您必须首先将键/值对添加到映射一样，然后才能更改值。这并不意味着“更改命令”必须始终与“添加命令”组合使用，因为密钥也可能已经存在。

Answer 1

我会冒险寻找答案，但我发现这个问题有点难以理解。

我会使用你的物品的副本。

而不是直接在您的对象上执行：
- 复印一份
- 在该对象上执行命令
如果没有触发异常
- 返回副本/用副本替换原件
别的
- 保留原件
（在你的情况下，在 catch 中保留原始内容）

我也同意封装你的命令：
我的意思是有一个必须一起执行的命令列表。

这样你就可以将你的代码转换为类似

  class SomeClass
    {
      public:
      struct Command
      {
        /*...*/
      };

      void ExecuteOneCommand( const Command &oneCommand )
      {
          /* either completely executes a command or throws exception and leave object in unchanged state */
      }

      SomeClass ExecuteCommands( const vector< Command > &commands )
      {
      SomeObject save = getCopy();
      try
      {

         ExecuteMultipleCommands(commands);
      }catch( /* some exception type */ )
      {
              return save
      }
      return this;    
      }

 void ExecuteMultipleCommands( const vector< Command > &commands )
      {

          vector< Command >::const_iterator it = commands.begin();
          for ( ; it != commands.end(); ++it )
          {
                  ExecuteOneCommand( *it );
           }
      }
    };

---

编辑的 东西
我刚刚意识到，如果您从类中提取保存部分，效果会更好：

SomeObject save = someObjectInstance.copy();
if(!someObjectInstance.executeCommands){
//free someObjectInstance
someObjectInstance = save;
}

Answer 2

我不知道有什么最好的方法可以做到这一点。这取决于您的命令正在做什么。如果某些命令依赖于其他命令，则每个命令中应该有一个依赖项列表，并且每个命令中应该有一个指示完成的标志。一旦调用命令，它应该在运行之前检查依赖关系以确保它们全部完整。如果您需要“回滚”命令，您只需复制该命令即可运行它，如果它运行没有异常，则将临时命令复制到原始命令并将完成设置为 true。如果您需要在依赖项失败时回滚，则可能需要将原始副本附加到已完成的原始文件上，将其复制回来并在依赖项失败时将其标记为不完整。如果不了解更多有关您的应用程序的信息，就很难知道您的要求是什么。

Answer 3

我认为只有 ExecuteMultipleCommands 的调用者才能充分处理异常。为了促进异常处理，您可以更改 ExecuteMultipleCommands 中的 catch 块并向异常添加额外信息：

void ExecuteMultipleCommands( const vector< Command > &commands )
{
    size_t command_index  = 0;
    try 
    {
       for ( command_index = 0; command_index < commands.size() ; command_index++)
       {
            ExecuteOneCommand(commands[command_index]);
       }
    }
    catch (OneCommandException &e)
    {
        MultipleCommandException new_exception = MultipleCommandException(e); 
       // assuming MultipleCommandException has a public constructor that accepts OneCommandException&
        new_exception.command_index = command_index;
        throw new_exception;
    }
}

Answer 4

这通常是通过处理副本来实现的。例如，.NET 中的 LINQ to SQL 将处理内存中的副本，然后立即处理所有更改，并在出现任何故障时回滚所有更改。

通常，您通过处理副本来保证回滚期间不会发生异常 - 也就是说，如果您没有明确成功地到达所有更改的末尾，则更改永远不会提交，因此回滚的行为只是破坏了副本，这是一个本质上安全的程序。