这种对流程结构的控制是很好的实践吗？

Question

我想重写一个嵌套了太多if语句的方法。

我想出了这个方法，并希望得到您的意见：

public void MyMethod()
{
   bool hasFailed = false;

   try
   {
      GetNewOrders(out hasFailed);

      if(!hasFailed)
          CheckInventory(out hasFailed);

      if(!hasFailed)
          PreOrder(out hasFailed);              

      // etc
   }
   catch(Exception ex)
   {
   }
   finally
   {
      if(hasFailed)
      {
           // do something
      }
   }
}

Answer 1

我做过类似的事情，但没有异常处理：

BOOL ok = CallSomeFunction();
if( ok ) ok = CallSomeOtherFunction();
if( ok ) ok = CallYetAnotherFunction();
if( ok ) ok = WowThatsALotOfFunctions();
if( !ok ) {
    // handle failure
}

或者，如果你想变得聪明：

BOOL ok = CallSomeFunction();
ok &= CallSomeOtherFunction();
ok &= CallYetAnotherFunction();
...

如果您正在使用异常，为什么需要hasFailed变量呢？

Answer 2

不怎么有意思。你的方法应该在你的"catch“块捕获到错误的情况下引发一个异常。

Answer 3

据我所知，这是一个级联步骤的例子，如果first和first和second是有效的，那么将执行第二个和第三个步骤，即返回hasFailed==false。

使用模板方法和Decorator设计模式可以使这段代码变得更加优雅。

您需要一个接口、具体的实现、抽象类和抽象类的几个子类。

public interface Validator {
    public boolean isValid();
}

public class GetNewOrders implements Validator {
    public boolean isValid() {
       // same code as your GetNewOrders method
    }
}

public abstract class AbstractValidator implements Validator {
    private final Validator validator;

    public AbstractValidator(Validator validator) {
        this.validator = validator;
    }
    protected boolean predicate();
    protected boolean isInvalid();

    public final boolean isValid() {
        if (!this.validator.isValid() && predicate() && isInvalid())
            return false;
        return true;
    }
}

public class CheckInventory extends AbstractValidator {
    public CheckInventory(Validator validator) {
        super(validator);
    }
    @Override
    public boolean predicate() {
        return true;
    }
    @Override
    public boolean isInvalid() {
        // same code as your CheckInventory method
    }
}

public class PreOrder extends AbstractValidator {
    public CheckInventory(Validator validator) {
        super(validator);
    }
    @Override
    public boolean predicate() {
        return true;
    }
    @Override
    public boolean isInvalid() {
        // same code as your PreOrder method
    }
}

现在你的方法看起来更优雅了：

public void MyMethod() {
    bool success = false;
    try {
        Validator validator = new GetNewOrders();
        validator = new CheckInventory(validator);
        validator = new PreOrder(validator);
        success = validator.isValid();
    } finally {
        if (!success) {
            // do something
        }
    }
} 

可以在一行中创建验证器对象，但我更喜欢这种风格，因为它使验证的顺序变得明显。在链中创建新的验证链接涉及到对AbstractValidator类进行子类化以及实现predicate和isInvalid方法。