执行顺序方法的最佳方法是什么

本文关键字：方法 是什么 最佳 执行 顺序 | 更新日期: 2023-09-27 17:47:23

处理一个项目，其中必须每x秒运行一组连续的方法。 现在，我拥有另一个"父方法"中包含的方法，并且只是按顺序调用它们。

class DoTheseThings()
{
    DoThis();
    NowDoThat();
    NowDoThis();
    MoreWork();
    AndImSpent();
}

每个方法都必须成功运行而不会引发异常，然后才能完成下一步。 所以现在我用一个while和try..catch包装了这些方法中的每一个，然后在catch再次执行该方法。

while( !hadError )
{
    try
    {
         DoThis();
    }
    catch(Exception doThisException )
    {
         hadError = true;
    }
}

这看起来很臭，不是很干。 有没有更好的方法来做到这一点，所以我不会以相同的方法包装任何新功能。 某种委托集合不是实现这一点的正确方法吗？

有没有更"合适"的解决方案？

执行顺序方法的最佳方法是什么

Action[] work=new Action[]{new Action(DoThis),   new Action(NowDoThat),    
    new Action(NowDoThis),    new Action(MoreWork),    new Action(AndImSpent)};
int current =0;
while(current!=work.Length)
{
   try
   {
      work[current]();
      current++;
   }
   catch(Exception ex)
   {
      // log the error or whatever
      // maybe sleep a while to not kill the processors if a successful execution depends on time elapsed  
   }
}

某种委托集合不是实现这一点的正确方法吗？

委托是解决此问题的可能方法。

只需创建一个类似以下内容的委托：

公共委托无效工作

委托（）;

并将它们放在可以迭代的数组列表中。

我个人的宗教信仰是，你不应该捕获System.Exception，或者更准确地说，你应该只捕获你知道如何处理的异常。

话虽如此，我将假设您调用的每个方法都在执行不同的操作，并可能导致引发不同的异常。 这意味着您可能需要为每个方法使用不同的处理程序。

如果你也遵循我的宗教，并且第二种说法是正确的，那么你就不会不必要地重复代码。 除非你有其他要求，否则我改进代码的建议是：

1）将try-catch放在每个方法中，而不是在每个方法调用周围。

2）让每个方法中的捕获仅捕获您知道的异常。

http://blogs.msdn.com/fxcop/archive/2006/06/14/631923.aspxhttp://blogs.msdn.com/oldnewthing/archive/2005/01/14/352949.aspxhttp://www.joelonsoftware.com/articles/Wrong.html

呵

呵......

你的例子似乎没问题.. 这是一个枯燥的例子，但会做得很好！！ 实际上，如果此方法执行数据库访问.. 您可以使用事务来确保完整性...

如果你处理多线程程序的共享变量......使用同步更干净..编码中最重要的是你编写正确的代码...错误较少..并将正确完成任务..

public void DoTheseThings()
{
    SafelyDoEach( new Action[]{
        DoThis,
        NowDoThat,
        NowDoThis,
        MoreWork,
        AndImSpent
    })
}
public void SafelyDoEach( params Action[] actions )
{
    try
    {
        foreach( var a in actions )
            a();
    }
    catch( Exception doThisException )
    {
        // blindly swallowing every exception like this is a terrible idea
        // you should really only be swallowing a specific MyAbortedException type
        return;
    }
}

发生错误的原因是什么？

如果这是资源问题，例如访问连接或对象等内容，则可能需要查看使用监视器、信号量或仅锁定。 

lock (resource) 
{
    Dosomething(resource);
}

这样，如果以前的方法正在访问资源，则可以等到它释放资源以继续。

理想情况下，您不必在每次失败时都运行循环来执行某些内容。它完全失败了，您会想知道问题并修复它。有一个循环总是不断尝试并不是正确的方法。

我会

按照Ovidiu Pacurar的建议去做，只是我会使用foreach循环并将处理数组索引留给编译器。

简单的委托方法：

Action<Action> tryForever = (action) => { 
   bool success;
   do {
     try {
       action();
       success = true;
     } catch (Exception) {
       // should probably log or something here...
     }
   } while (!success);
};
void DoEverything() {
   tryForever(DoThis);
   tryForever(NowDoThat);
   tryForever(NowDoThis);
   tryForever(MoreWork);
   tryForever(AndImSpent);
}

堆栈方法：

void DoEverything() {
  Stack<Action> thingsToDo = new Stack<Action>(
    new Action[] { 
      DoThis, NowDoThat, NowDoThis, MoreWork, AndImSpent 
    }
  );
  Action action;
  while ((action = thingsToDo.Pop()) != null) {
     bool success;
     do {
       try {
         action();
         success = true;
       } catch (Exception) {
       }
     } while (!success);
  }
相关文章：