如何避免異常捕獲.NET中的複製粘貼

Question

使用.NET框架我有一系列可以生成多種類型異常的方法的服務：MyException2，MyExc1，Exception ...爲所有人提供適當的工作方法，他們每個人都包含以下幾個部分：

[WebMethod] 
void Method1(...) 
{ 
    try 
    { 
     ... required functionality 
    } 
    catch(MyException2 exc) 
    { 
     ... process exception of MyException2 type 
    } 
    catch(MyExc1 exc) 
    { 
     ... process exception of MyExc1 type 
    } 
    catch(Exception exc) 
    { 
     ... process exception of Exception type 
    } 
    ... process and return result if necessary 
} 

這是很無聊的用完全相同的異常處理功能，具有完全相同的東西，在每個服務方法（每種方法都有不同的參數）...

是否有可能將這些catch部分「分組」並僅使用一行（與C++宏類似）？可能.NET 4.0中的新東西與此主題有關？

謝謝。

P.S.任何想法都歡迎。

Answer 1

如果異常處理正是在您所有的方法都是一致的，你可以這樣做：

void CallService(Action method) 
{ 
    try 
    { 
     // Execute method 
     method(); 
    } 
    catch(MyException2 exc) 
    { 
     ... process exception of MyException2 type 
    } 
    catch(MyExc1 exc) 
    { 
     ... process exception of MyExc1 type 
    } 
    catch(Exception exc) 
    { 
     ... process exception of Exception type 
    } 
} 

然後，你可以只重寫你的客戶端代碼做：

int i = 3; 
string arg = "Foo"; 
this.CallService(() => this.Method1(i)); 
this.CallService(() => this.Method2(arg, 5)); 

這使您的Method1和Method2方法變得簡單：

void Method1(int arg) 
{ 
    // Leave out exception handling here... 
    ... required functionality 
    ... process and return result if necessary 
} 

void Method2(string stringArg, int intArg) 
{ 
    // Leave out exception handling here... 
    ... required functionality 
    ... process and return result if necessary 
} 

Answer 2

我知道這是不好的做法，但是如果您在每個catch語句中都有完全相同的錯誤處理，何時不只是最後一個catch語句作爲catch語句？

這當然假定您的所有異常繼承自Exception。

Answer 3

爲什麼不把代碼分解成一個輔助方法來爲你做這件事（你可以將未來需要的任何新異常添加到HandleException中，這使得它非常具有伸縮性）？

try 
{ 
    ... required functionality 
} 
catch (Exception e) 
{ 
    HandleException(e); 
    throw; // only if you need the exception to propagate to caller 
} 


private void HandleException(Exception e) 
{ 
    if (e is MyException2) 
    { 
     ... process exception of MyException2 type 
    } 
    else if (e is MyExc1) 
    { 
     ... process exception of MyExc1 type 
    } 
    else 
    { 
     ... process exception of Exception type 
    } 
} 

Answer 4

我會仔細看看你在做什麼來「處理」這些異常。很有可能你根本不需要catch塊，並且你應該允許異常傳播。

Answer 5

在突然間出現的怪異（並顯示你可以但可能不應該也不想做的事情）：通過生成包含異常的函數，可以使整個事情更加可組合和可重用處理邏輯：

static class ExceptionHandlerExtensionMethods 
{ 
    // extend to Func<T> as desired 
    public static Action Catching<T>(this Action what, Action<T> handler) 
     where T : Exception 
    { 
     return() => 
     { 
      try 
      { 
       what(); 
      } 
      catch (T ex) 
      { 
       handler(ex); 
      } 
     }; 
    } 
} 

現在，您可以實現和重用的異常類型特定處理函數的地方，並把它們組合成一些其他的方法的異常處理。

要刪除冗餘，您可以編寫一個輔助函數，將「典型」異常處理函數添加到您想要調用的任何地方，並調用此裝飾方法。

Answer 6

從裏德·科普塞使用CallService方法：

void DoSomething(object param1, int param2) 
{ 
    this.CallService(() => 
    { 
     // work with param1 and param2 here 
    } 
} 

因爲當你需要返回一個值的情況下，你可能需要重複CallService返回一個類型參數。

T CallService<T>(Func<T> callback) { /* ... */ } 

Answer 7

我在類似情況下完成了以下操作。我將展示的技術中以兩個步驟...

---

步驟1.創建爲其它代碼的特定執行上下文的方法：

// this static method is responsible for setting up a context for other code 
// to run in; specifically, it provides the exception handling "plumbing": 
public static void guarded(Action action) 
{      // ^^^^^^^^^^^^^ 
    try    // actual code to be executed 
    { 
     action(); 
    } 
    catch (SomeExceptionA ea) 
    { 
     // handle exception... 
    } 
    catch (SomeExceptionB eb) 
    { 
     // handle exception... 
    } 
    // etc. 
} 

---

步驟2 。應用這方面的任何一段代碼：

接下來，你簡單的「包裝」這個異常周圍的行爲處理UAL代碼在你的方法：

public void MethodA() 
{ 
    guarded(() => // <-- wrap the execution handlers around the following code: 
    { 
     // do something which might throw an exception... 
    }); 
} 

public void MethodB() 
{ 
    guarded(() => 
    { 
     // do something which might throw an exception... 
    }); 
} 

---

摘要：

這裏的一般想法是寫（在上面的例子guarded）的功能，設置了具體的執行上下文的其他代碼（本例中的上下文提供了異常處理。）在這個上下文中執行的代碼是作爲lambda函數提供的。你甚至可以調整上下文創建函數，以便lambda函數中的代碼可以返回一個值。