Framework Patterns: Exception Handling, Logging, and Tracing

This chapter is from the book

.NET Patterns: Architecture, Design, and Process

Learn More Buy

This chapter is from the book

This chapter is from the book 

.NET Patterns: Architecture, Design, and Process

Learn More Buy

Those already familiar with Java exception handling should feel quite comfortable with the .NET implementation. In fact, if you are reading this book, you should already be throwing and catching exceptions in your code. However, I would like to go over some “advanced-basics” in the area of exception handling before we move on to creating a “base exception” class (sprinkled with a few implementation patterns). Error, or exception handling is one of those things that everyone does but unfortunately, few do it very well. With robust handling, logging, and display, your applications will better stand the test of time and should save you hours in product support. From here forward, I use the word exception in place of error, and vice versa; neither is meant to be distinctive of the other. I assume throughout this chapter that you have already had some experience working with structured exception handling (SEH) because this will not be a tutorial on its basics.

Figure 2.1 illustrates a typical exception-handling scenario. This should provide you generally with the proper flow of throwing and catching exceptions. You'll notice that once an exception is deemed unrecoverable, information is then added to provide the system with as much information as possible for determining the problem. This is where a base exception class becomes useful. Typically, the more you can centralize value-added features to this class, the easier it will be to integrate and leverage from within your framework. This is especially true of large development teams. How many times have there been framework features that were useful but unused? By centralizing important functionality such as logging in your base class and by standardizing how the exceptions should be thrown, you help guarantee its proper use. This also takes any guesswork out of proper exception handling for those developers using your framework. In an upcoming section, I will provide some of the steps for creating such a base class.

Figure 2.1. Exception flow: How most exceptions should be handled.

Application-Specific Exceptions

Like its C++ and Java predecessors, .NET uses a base System.Exception class as the parent of all thrown exceptions. Many applications can simply use this base class for throwing errors and are not required to implement their own. You may also wish to stick with using the System.SystemException-derived exceptions that come with the FCL. These include exception classes such as System.Web.Services.Protocols.SoapException or System.IO.IOException. System exceptions of these types will also be used throughout the samples in this book. However, for special handling scenarios or to enhance your architecture, it is advisable to build your own exception base class. From there, you can begin to add functionality common to all exception handling for your framework.

From a base exception class, you can create specific error-handling classes and further centralize the process by which errors should be handled, displayed, and recorded in your architecture. This includes general framework exceptions, such as the sample FtpException class you will see shortly, but it also includes all those business rule-specific scenarios that warrant special handling. All custom application exceptions, including your own framework exceptions, should derive from System.ApplicationException and not System.Exception directly. Even though System.ApplicationException directly derives from System.Exception, they have identical features. However, it is important to make the distinction between the two when designing your exception classes.

Rather than using method return codes such as the HRESULTS that we have come to know and love with COM, .NET is a type-based system that relies on the exception type to help identify errors. Throwing the appropriate exception type during a given scenario is as important as specifying the correct HRESULT in the world of COM. This doesn't mean we forgo all error codes. It simply means that leveraging the exception types will initiate a more robust error-handling system.

An example of a feature-specific exception handling class can be found when providing FTP services in your architecture (as shown below). Later, I will describe how this is used when we talk about creating protocol-specific requesters in the next chapter. I am just using this as a simple example, so bear with me. Here, the exception class is expanded to facilitate FTP-specific errors and the protocol return codes that are used to describe the error. The code displayed simply delegates most of the handling to the base class BaseException. Our BaseException class will be described shortly. The point here is that I can now better control how FTP errors should be handled.

In this example, I am simply displaying the error in a specific format when the Message property is used. Building function-specific exception classes also eliminates the guesswork for developers having to utilize an existing framework: If a specific exception class is provided, use it. If certain rules dictate even a future possibility of special error processing, error display, or error recording, then building a custom exception class would be prudent. Once the base exception class is built for a framework, function-specific exception classes can be driven from a template, such as the following:

Listing 2.1 A sample BaseException child class.

public class FtpException : BaseException
{
   /// <summary>
   /// Message for the ftp error
   /// </summary>
   private string m_sMessage;

   public FtpException(){;}

   public FtpException(string sMessage, bool bLog) :
         base(sMessage, bLog){;}

   public FtpException(string sMessage, System.Exception
      oInnerException, bool bLog) : base(sMessage, oInnerException,
         bLog){;}

   public FtpException(object oSource, int nCode, string sMessage,
        bool bLog) : base(oSource, nCode, sMessage,      bLog){;}

   public PMFtpException(object oSource, int nCode, string sMessage,
         System.Exception oInnerException, bool bLog) :
         base(oSource, nCode, sMessage, oInnerException, bLog){;}

   public new string Message
   {
         get
         {
               int nCode = base.Code;
               string sMessage = GetFtpMessage(nCode);
               return new StringBuilder(
                                 "FTP Server stated:[")
                                 .Append(nCode)
                                 .Append(" ")
                                 .Append(sMessage)
                                 .Append("]")
                                 .ToString();
         }
         set {m_sMessage = value;}
   }

The Listing 2.1 example is not all that different from a regular exception, other than two things. We use this FtpException class to display our FTP error in a specialized way. With the following helper function, I am using the returned FTP code to look up the corresponding FTP error message from a string table called FTPMessages through the System.Resources.ResourceManager. Once the code description is returned, I then build the custom FTP error message, using both the code and the description.

Listing 2.2 One example of a "value-added" operation on a base exception child.

/// <summary>
/// Helper to return messages from ftp message resource string table
/// </summary>
/// <param name="sCode"></param>
/// <returns></returns>
public static string GetFtpMessage(int nCode)
{
   FtpMessages = new ResourceManager("FTPMessages",
      Assembly.GetExecutingAssembly());
   FtpMessages.GetString(new StringBuilder("Code_")
                           .Append(nCode).ToString());
}

The other differentiator between my FtpException class and any other System.ApplicationException class is the constructors for this class. Notice that most of the constructors delegate to the BaseException class. This is where most of the exception handling is done. Features handled by the BaseException class include some of the following, which I will talk about in more detail in this chapter:

• Automated Exception Chaining— Handles each exception as it gets passed back up to the caller of the method containing the exception. As each exception is thrown, the cause of the exception is passed as the “inner exception” thus becoming part of the newly thrown error. This continues up the chain until the information gathered can be used for tracking the original error, logging, or handling in some other fashion.

• Automated Error Stack Formatting and Display— While exceptions are chained, they can be tracked by building an error stack containing each chained exception. Typically, this is accomplished by capturing the important elements during chaining and building a string that can be displayed or made durable.

• Automated Call Stack Formatting and Display— This is identical to that of building an error stack exception. The .NET framework automates this by providing an error stack property that can be accessed at any time. The error stack will provide details as to the method and line number causing the error. This information can also be made durable or displayed.

• Custom Remote Exception Handling Using SOAP— For exceptions thrown directly from Web services, this can circumvent the FCL's own default SOAP exception handling. Providing custom handling here will give you a greater level of control, especially when formatting an SOAP Fault, as we will see in the SOAP Fault technology backgrounder later in this chapter.

• Error Logging and Message Tracing— Provides the mechanism by which the exceptions are communicated and/or made durable during handling.

Figure 2.2 should give you a visual idea of how exception handling, chaining, and logging look from a framework perspective.

Figure 2.2. Exception chaining: How exceptions are chained using the InnerException property.

Logging is not the most important of these base exception features. Most errors in some way at some point should be made durable. The user may not have the luxury of viewing a message box with an error description or even understand the error message when it is displayed. It is up to you to provide a facility for recording or routing error messages so that the error either gets handled later or is read by those who can help. As a product support feature, this is a must. In the next section, I will show how you can enrich your exception handling by designing a base class to facilitate this.