C# 异常处理中的设计模式

我实际上正在编写一个库类，它可以被多个类使用。我把这个例子简单化是为了说明问题。假设我有三个班：A、B和C：

public class B
{
  public static string B_Method()
  {
    string bstr = String.Empty;

    try
       {


        //Do Something

       }

    catch
        {

        //Do Something

        }

  return bstr;

}

B是我正在写的图书馆课。现在有另外两个类，比如A和C：

public class A
{
  public void A_Method()
  {
   string astr = B.B_Method();
  }

}

public class C
{
 public void C_Method()
  {
   string cstr = B.B_Method();
  }

}

问题是关于异常处理的。我希望两个类A和B各自的方法以各自不同的方式处理B_方法中发生的异常

---

我寻找框架设计模式，但觉得没有用。

我通常采用的方法是：

• 如果我的方法可以在异常情况下做一些有用的事情，我将捕获它并执行该操作
• 如果没有，我就不会捕捉到它，而是让调用代码来处理它

我将放置“catch all”块的唯一位置是UI代码中的入口点（例如用于按钮单击的事件处理程序等），因为不捕获那里的异常可能会导致进程停止

这也意味着异常子句应该捕获您可以处理的特定异常

---

我有时看到的一种方法是捕获异常，将其包装成新的异常类型并抛出该异常。虽然这为您提供了一些可跟踪性，但我也觉得它删除了调用代码中异常处理中的一些选项，例如为不同的场景使用特定的catch子句。在这些情况下，您将需要使用if子句检查内部异常，在我看来，它的可读性较低。

您可以在B_方法中重新抛出异常，然后在A和C类中捕获它

public class A
{
  public void A_Method()
  {
   try
   {
     string astr = B.B_Method();
   }
  catch(Exception ex)
  {
    //Handle it in A way
  }

}

public class C
{
 public void C_Method()
  {
   try
   {
     string astr = B.B_Method();
   }
  catch(Exception ex)
  {
    //Handle it in C way
  }
}

我认为设计模式在这里并不适用。。这只是面向对象编程

B是我正在写的图书馆课

如果您可以控制

B

code，

B

应该重新

抛出捕获的异常：

public class B
{
    public static string B_Method()
    {
        string bstr = String.Empty;

        try
        {
            // Do Something
        }
        catch(Exception e)
        {
            // Do Something (Log the exception details)
            throw;
        }

        return bstr;
    }
}

我希望两个类A和B各自的方法以各自不同的方式处理B_方法中发生的异常

现在，
B
可以记录异常，
A
和
C
可以按照自己的方式处理重试异常。
从类B中删除try-and-catch块

public static string B_Method()throws Exception{
    boolean success=compute();
    if(!success){
       throw new Exception("an error occured");
     }
} 
private static boolean compute(){
    return false;
}

如果您想让调用方处理异常，为什么B要捕获异常？那么为什么不让异常从B_方法传播，让调用方执行try/catch？比方说，B_方法向服务器发送请求并获得响应。它发送回调用方的响应相同。如果我在发送请求时没有捕获异常，那么执行不会停止吗？没错。例外情况应该很少被发现。只有当你知道如何处理这些。它们并不是无缘无故地被称为异常以这种方式重新引用异常是一种非常糟糕的做法。呼叫投掷；使用完整堆栈或创建新的自定义异常。