为什么在c＃异常类中没有带有1异常参数的构造函数？

Question

System.Exception class has 4 constructors:

public Exception();
public Exception(string message);
protected Exception(SerializationInfo info, StreamingContext context);
public Exception(string message, Exception innerException);

Why it does not have this constructor?

public Exception(Exception innerException);

This is one place where it would have been helpful.

I have a static method to get an open connection:

public static DbConnection GetOpenConnection(string dataProvider, string connectionString) 
{
   DbConnection dbConnection = GetDbProviderFactory(dataProvider).CreateConnection();
   dbConnection.ConnectionString = connectionString;
   dbConnection.Open();
   return dbConnection;
}

I want this method to throw a custom exception GetOpenConnectionException if any error occured.

So I created the custom exception GetOpenConnectionException :

public class GetOpenConnectionException : Exception
{
   public GetOpenConnectionException(string message) : base(message)
   {
   }
   public GetOpenConnectionException(string message, Exception innerException) : base(message, innerException)
   {
   }
}

Since Exception does not have a constructor public Exception(Exception innerException) , I cannot have this code in GetOpenConnectionException :

public GetOpenConnectionException(Exception innerException) : base(innerException)
{
}

So I am forced to code the GetOpenConnection() method this way:

public static DbConnection GetOpenConnection(string dataProvider, string connectionString) 
{
   try 
   {
      DbConnection dbConnection = GetDbProviderFactory(dataProvider).CreateConnection();
      dbConnection.ConnectionString = connectionString;
      dbConnection.Open();
      return dbConnection;
   }
   catch (Exception e)
   {
      throw new GetOpenConnectionException("", e);
   }
}

What I wanted is to code the GetOpenConnection() method this way:

public static DbConnection GetOpenConnection(string dataProvider, string connectionString) 
{
   try 
   {
      DbConnection dbConnection = GetDbProviderFactory(dataProvider).CreateConnection();
      dbConnection.ConnectionString = connectionString;
      dbConnection.Open();
      return dbConnection;
   }
   catch (Exception e)
   {
      throw new GetOpenConnectionException(e);
   }
}

Does this make sense?

Answer 1

   public GetOpenConnectionException(Exception innerException) : base("", innerException)
   {
   }

Answer 2

Other answers provide good ways to achieve what you are asking for, but I believe the heart of your question is: "Why didn't this exist in the first place?"

Exceptions are normally thrown when a routine's assumptions or prerequisites about the resources it uses and the arguments it asks for are not met. The exception thrown should help the caller (or programmer) understand what assumption or prerequisite was not met, so that they can handle it accordingly or fix their code. The message is a critical part of that communication. I would even hazard a guess that if the Exception class didn't need to be serializable, there wouldn't even be an empty constructor!

Nesting an exception inside of another implies that the nested exception is the cause of the container exception. (The documentation for that particular constructor of the Exception class points to this a bit.) If you simply pass an inner exception without any message, that effectively translates to "I am going to throw an exception which provides no additional information beyond it's type." That's not very helpful, and it would probably have been nicer to simply let the original exception be thrown.

Here's one way you could provide a more meaningful message:

public static DbConnection GetOpenConnection(string dataProvider, string connectionString) 
{
   try 
   {
      DbConnection dbConnection = GetDbProviderFactory(dataProvider).CreateConnection();
      dbConnection.ConnectionString = connectionString;
      dbConnection.Open();
      return dbConnection;
   }
   catch (Exception e) // consider changing this to a more specific type of exception, as an error with .Open() is not the only way it could fail
   {
      // provide a meaningful message to the caller about the context of this error
      var message = string.Format("An error occurred while trying to connect to the data provider {0} with the connection string {1}.", dataProvder, connectionString);
      throw new GetOpenConnectionException(message, e);
   }
}

Answer 3

Similar to Piotr Dory's answer, you could do this:

public GetOpenConnectionException(Exception innerException) :
    base(innerException.message, innerException)
{
}

This way you're actually passing something meaningful into the base constructor.

As to why there isn't a constructor that only takes an Exception argument... it doesn't seem there is actually a good reason. They easily could have.