Do you catch exceptions precisely?

In a try-catch block, avoid catching generic Exception types as this masks the underlying problem. Instead, target only the specific exceptions you can manage, which helps in accurately identifying and rectifying the error.

It is essential to foresee the exceptions that the code in the try block might raise. Catching these specific exceptions at the point of occurrence provides the most context for effectively addressing the issue.

try
{
     connection.Open();
}
catch (Exception ex)
{
     // Omitted for brevity
}

❌ Bad code – Catching the general Exception

try
{
     connection.Open();
}
catch (InvalidOperationException ex)
{
     // Omitted for brevity
}
catch (SqlException ex)
{
     // Omitted for brevity
}

✅ Good code - Catch with specific Exception

To further elaborate, here are some reasons why catching specific exceptions is important:

1. Contextual Handling - Specific exceptions enable tailored responses. You can close resources in response to an IOException or take other actions for a NullPointerException.
2. Code Readability - Specific exceptions make code more readable. They allow developers to better anticipate potential errors, making the code easier to maintain.
3. Debugging and Traceability - A detailed exception type speeds up debugging. A general exception conceals the root cause and complicates diagnosis.
4. Logging - Catching a specific exception enables detailed logging, crucial for post-mortem analysis.
5. Forward Compatibility - Specific exceptions minimize the risk of future updates causing unintended issues. A broad Exception class could inadvertently catch new, unrelated exceptions.
6. Error Recovery - Knowing the exact type of exception informs whether to retry an operation, failover, or terminate the program.
7. Resource Optimization - Catching broad exceptions is computationally expensive. Targeting specific exceptions allows for more optimized code.

Global exception handlers for a program are an exception to the rule, as they need to catch any uncaught exceptions for the sake of good user experience. Frameworks often provide mechanisms for this scenario, such as:

• ASP.NET Core - You can use exception handler pages, middleware and exception handler lambdas
• Mediator pattern - you can use error handling middleware