Exception policy is like creating a group under which one or more exception types are configured and under each exception type, one or more handlers can be configured. For example, we might have Data Access Exception Policy to handle data access-related exceptions with multiple exception types such as DBConcurrencyException, DbException, and so on. While configuring the exception policy we have to provide a unique name, which can be used in the application code to process the exception.

The following class diagram shows the method exposed by the ExceptionPolicy class:

Exception type is nothing but any type that inherits from System.Exception; based on the configuration the application block chooses the matching exception type in the class hierarchy. If an exception of type System.NotFiniteNumberException is thrown and the policy is configured to handle exceptions of types System.Exception and System.ArithmeticException then the application block will process the exception using System.ArithmeticException based on the class hierarchy. While configuring the exception type, we have to decide on the post handling action. There are three options to choose from.

Exception handlers are .NET classes that implement the Exception Handling block's interface called IExceptionHandler. The application block includes the four commonly required handlers Wrap, Replace, Logging, and Fault Contract Exception Handler (used to guard the WCF service boundary and generate new fault contract from the exception). We can also implement custom handlers to meet our custom requirements and configure them in the configuration file using the editor.

The following class diagram shows various concrete implementations of exception handlers and the IExceptionHandler interface:

The description of each of the concrete exception handlers is given as follows:

ExceptionManager is one of the key classes of the Exception Handling Application Block; this abstract class is part of the Microsoft.Practices.EnterpriseLibrary.ExceptionHandling namespace. It acts as an entry point to the exception handling functionality and provides two different ways to manage exceptions. The signatures of both the HandleException and Process methods are given next. The actual implementation is provided by the ExceptionManagerImpl class, which inherits from the ExceptionManager class.

The following class diagram shows the inheritance hierarchy and methods exposed by ExceptionManager and the ExceptionManagerImpl class:

try
{
BusinessLayer.BlogManager blogManager = new BusinessLayer.BlogManager();
//Get Blog Post
BusinessLayer.BlogPost post = blogManager.GetBlogPost(0);
}
catch (ArgumentException ex)
{
Exception exceptionToRethrow;
//Get instance of ExceptionManager using static method of Enterprise Library Container
ExceptionManager exManager = EnterpriseLibraryContainer.Current.GetInstance<ExceptionManager>();
//Call to HandleException method
//Return value indicates whether to re-throw the exception
bool rethrow = exManager.HandleException(ex, "General Policy", out exceptionToRethrow);
if (rethrow) throw exceptionToRethrow;
}

//Get instance of ExceptionManager using static method of Enterprise Library Container
ExceptionManager exManager = EnterpriseLibraryContainer.Current.GetInstance<ExceptionManager>();
BusinessLayer.BlogPost post = null;
BusinessLayer.BlogManager blogManager = new BusinessLayer.BlogManager();
//try..catch block not required...
//Automatic Exception Management through Process method
post = exManager.Process<BusinessLayer.BlogPost>(
() => { return blogManager.GetBlogPost(0); },
"Data Access Policy"
);

ExceptionPolicy is a static class and is part of the Microsoft.Practices.EnterpriseLibrary.ExceptionHandling namespace. This class contains static methods to handle exceptions. Internally, it leverages EnterpriseLibraryContainer, which is part of the Microsoft.Practices.EnterpriseLibrary.Common.Configuration namespace. This class is an entry point for the container infrastructure for the Enterprise Library. The ExceptionPolicy class was the default approach to handle exceptions in versions prior to 5.0. This approach is no longer recommended and is still available for backwards compatibility.

The following is the syntax to handle exceptions using the ExceptionPolicy static class:

try
{
//Potentially exceptional area :)
}
catch (Exception ex)
{
bool rethrow = ExceptionPolicy.HandleException(ex, "UI Policy");
if (rethrow)
{
throw;
}
}

This approach is recommended for applications with few dependencies. The EnterpriseLibraryContainer class exposes a static property called Current of type IServiceLocator, which resolves and gets an instance of the specified type.

The following is the syntax to create an instance of ExceptionManager using Unity service locator:

//Get instance of ExceptionManager using static method of Enterprise Library Container
ExceptionManager exManager = EnterpriseLibraryContainer.Current.GetInstance<ExceptionManager>();

Larger complex applications demand looser coupling. This approach leverages the dependency injection mechanism to create objects instead of explicitly creating instances of concrete implementations. Unity container resolves objects using type registrations and mappings; these can be configured programmatically or through a configuration file. Based on the configuration, it resolves the appropriate type whenever requested. The following example instantiates a new Unity container object and adds the Enterprise Library Core Extension. This loads the configuration and makes registrations and mappings of Enterprise Library available.

The following is the syntax to create an instance of ExceptionManager directly using Unity Container:

var container = new UnityContainer();
container.AddNewExtension<EnterpriseLibraryCoreExtension>();
ExceptionManager exManager = container.Resolve<ExceptionManager>();