A bit about Exceptions
C# has introduced possibly the best tool to use for application error trapping: The exception. An exception is an error condition that is raised whenever your application misbehaves or identifies a problem that needs to be dealt with right away. This tutorial requires that you have a basic understanding of C# (or Java) exceptions and that you have used them a few times in your code.
The purpose of this tutorial is to explain firstly how you would go about creating your own set of exceptions to trap error conditions that could occur in your code or library, for your own benefit or for the benefit of another developer using your library. The second lesson is on how the C# exception stack works, and how you can use it to catch all types of exceptions.
Let's Begin!
The C# Exception Stack
Every exception that is defined within the .NET framework derives from a class called Exception. This class is used to describe a general error, whose specificity is not known. For example, a general exception could be an error that is not related in any way to errors that can occur from a library you are using.
Every exception inherits from the base class Exception in order to provide a more specific response to the developer. A SocketException indicated to the developer that something went wrong while he was trying to perform an operation with the Socket class or one of it's children. There could be a further child exception called TCPStreamException, derived from SocketException, which describes error conditions relating to the transmission of streamed data across a socket.
The result of this inherited characteristic is that you can set up an exception stack to trap errors, starting from the most-specific error possible to the least-specific known error. This means that a developer, when performing TCPStream operations, must trap for possible exceptions in the following order: TCPStreamException -> SocketException -> Exception. This will allow him to trap all possible errors, and act intellengently according to the type of exception encountered.
In my example source code, I have three exceptions. From parent to child:
Exception->VehicleException -> MotorCarException-> FerrariException. This follows the classic object inheritance example of Object->Vehicle->MotorCar->Ferrari. Can you see how each exception object has a direct connection to the physical object it raises an error for? Examine the source code in the CheckCar class and you will see the order that each exception is trapped.
Creating your own Exceptions in C#
This becomes a very useful tool when you start creating libraries of code to be used in your application. Each library which is built to perform a specific task, should have it's own set of exceptions that alert the developer of error conditions that can arise when the library is used.
For example, if you have a library that parses a string, but cannot accept the character '&'. You would then create an exception called BadCharacterException which will be thrown each time the application tries to parse a string containing the '&' character.
I have created three types of exceptions in my example below. Each exception inherits from its symbolic parent, and not from the base class Exception. This is important when the exception is to be trapped in the stack by the developer.
When creating your own exception class, you will inherit from Exception or an object that eventually inherits from Exception. In the constructor you need to override the base class' constructors in order to provide the correct feedback for the exception. The most commonly overridden constructor is
public Exception (string errorMessage)
This is used to set the error message for the exception object. You will need to initialise the base class with this message too, so use the following in your constructor declaration
public MyException (string errorMessage) : base(errorMessage) {
So, you as a library developer will want to throw this exception each time you identify that an error condition has occurred. When you throw it, you will use the following syntax, with a bit of text to describe what has gone wrong. This text is used mainly for debugging and tracing purposes.
if (errorCondition = true) {
throw new MyException("The error condition has occurred.");
}
The Example
The code attached below shows you how to firstly create your own exceptions and then how to trap them in a correctly-formatted try-catch block, otherwise known as an Exception stack.
It uses a class-per-exception, to keep within the inheritance model and its relationship to the matching object model.
It was written in Csharp for .NET beta 2.