Which exceptions shouldn't I catch?

Question

I have an app that runs a long batch process where many exceptions could potentially be thrown. If a non-critical exception is thrown during one item in the batch, I want to

Answer 1

Don't catch any exceptions you don't know how to handle safely.

Catching Exception is a particularly bad practice, the only one worse is a catch that doesn't specify any managed exception type (as it would catch non-managed exceptions as well).

Answer 2

Catch errors that you expect your code to throw.. When ever you are using an API or a method see what exceptions it will throw and catch only those.. You shouldn't make a list f exceptions and always catch those..

• Read from msdn google exception handling best practices
• Never catch wit the non-specific exceptions like Exception

Answer 3

I would refer to the advice from the following article.

.NET Framework design guidelines rules: Do Not Catch Exceptions That You Cannot Handle

http://www.codeproject.com/KB/cs/csmverrorhandling.aspx

Also from the referenced article:

You should never catch System.Exception or System.SystemException in a catch block

Answer 4

A more proper design would be supported by the question: Which exceptions should I catch?

If you really need to catch any and all exceptions and still keep going, then you should be using both AppDomains and separate worker processes. Or change your host to ASP.NET or the task scheduler, which have already done all the hard work around process isolation and retries.

Answer 5

You don't need a list of 'bad' exceptions, you should treat everything as bad by default. Only catch what you can handle and recover from. CLR can notify you of unhandled exceptions so that you can log them appropriately. Swallowing everything but a black listed exceptions is not a proper way to fix your bugs. That would just mask them. Read this and this.

Do not exclude any special exceptions when catching for the purpose of transferring exceptions.

Instead of creating lists of special exceptions in your catch clauses, you should catch only those exceptions that you can legitimately handle. Exceptions that you cannot handle should not be treated as special cases in non-specific exception handlers. The following code example demonstrates incorrectly testing for special exceptions for the purposes of re-throwing them.

public class BadExceptionHandlingExample2 {
    public void DoWork() {
        // Do some work that might throw exceptions.
    }
    public void MethodWithBadHandler() {
        try {
            DoWork();
        } catch (Exception e) {
            if (e is StackOverflowException ||
                e is OutOfMemoryException)
                throw;
            // Handle the exception and
            // continue executing.
        }
    }
}

Few other rules:

Avoid handling errors by catching non-specific exceptions, such as System.Exception, System.SystemException, and so on, in application code. There are cases when handling errors in applications is acceptable, but such cases are rare.

An application should not handle exceptions that can result in an unexpected or exploitable state. If you cannot predict all possible causes of an exception and ensure that malicious code cannot exploit the resulting application state, you should allow the application to terminate instead of handling the exception.

Consider catching specific exceptions when you understand why it will be thrown in a given context.

You should catch only those exceptions that you can recover from. For example, a FileNotFoundException that results from an attempt to open a non-existent file can be handled by an application because it can communicate the problem to the user and allow the user to specify a different file name or create the file. A request to open a file that generates an ExecutionEngineException should not be handled because the underlying cause of the exception cannot be known with any degree of certainty, and the application cannot ensure that it is safe to continue executing.

Eric Lippert classifies all exceptions into 4 groups: Fatal, 'Boneheaded', Vexing, Exogenous. Following is my interpretation of Eric's advice:

  Exc. type | What to do                          | Example
------------|-------------------------------------|-------------------
Fatal       | nothing, let CLR handle it          | OutOfMemoryException
------------|-------------------------------------|-------------------
Boneheaded  | fix the bug that caused exception   | ArgumentNullException
------------|-------------------------------------|-------------------
Vexing      | fix the bug that caused exception   | FormatException from 
            | (by catching exception  because     | Guid constructor
            | the framework provides no other way | (fixed in .NET 4.0 
            | way of handling). Open MS Connect   | by Guid.TryParse)
            | issue.                              | 
------------|-------------------------------------|-------------------
Exogenous   | handle exception programmatically   | FileNotFoundException 

This is roughly equivalent to Microsoft's categorization: Usage, Program error and System failure. You can also use static analysis tools like FxCop to enforce some of these rules.

Answer 6

Unless you apply HandleProcessCorruptedStateExceptions attribute to an exception handling function, all the 'shouldn't be handled by the user code' exceptions are already ignored you so you can handle anything other than process corrupting exceptions safely.