1. Exception Handling Strategies
2. Exception Handling Strategy - Overview
3. Exception Handling Requirements
4. Application Survival
5. Notifying Relevant Parties
6. Error Diagnostics and Reproduction
7. Separation of Abstraction Layers
8. More Readable and Maintainable Code
9. Error Location and Context
10. Error Causes, Types and Reactions
11. Strategy Elements
12. Error Detection
13. Error Information Gathering
14. Throwing Exceptions
15. Propagating Exceptions
16. Catching Exceptions
17. An Exception Handling Strategy Template
18. An Exception Class Template
19. Throwing the AppException
20. Propagating the AppException
21. The ErrorInfo List
22. Catching the AppException
23. Avoid Exception Hierarchies

An exception handling strategy consists of all actions and conventions necessary to properly handle exceptions in your application.

The following diagram shows an overview of the various parts of an exception handling strategy, from the error is detected, all the way up to where the error is handled.

An exception handling strategy overview.

At the bottom of the strategy is errror detection. You detect an error either youself, or you catch a third party exception (AKA alien exception).

At the second level you try local exception handling if possible. This is where you e.g. send your request to a backup server or wait X seconds and try again, etc. You do what you can, if anything, to handle the error and continue whatever operation your application was currently carrying out.

At the third level, when local error handling did not work, you gather all the information necessary to diagnose, reproduce and report the error.

At the fourth level you convert the caught exception, or the error detected, into an application specific exception, and throw it. You add any information necessary to properly handle the exception.

At the fifth level you propagate the application specific exception up the call stack, closing any opened resources on the way up (like files, network connections, freeing allocated buffers etc.). Additionally, you add any contextual information which may be useful in determining the cause and severity of the error.

At the sixth level you catch and react to the exception. At this point local exception handling is no longer possible, so most often the only thing your application can do is to notify users, and non-users of the exception. If the exception is really, really bad your application may even shut down gracefully.