Custom Exceptions






Custom Exceptions

The intrinsic exception types the CLR provides, coupled with the custom messages shown in the previous example, will often be all you need to provide extensive information to a catch block when an exception is thrown.

There will be times, however, when you want to provide more extensive information or need special capabilities in your exception. It is a trivial matter to create your own custom exception class. Figure illustrates the creation of a custom exception.

A custom exception

using System;

namespace ACustomException
{
   // custom exception class
   public class MyCustomException :
   System.Exception
   {
      public MyCustomException( string message ):
      base( message ) // pass the message up to the base class
      {

      }
   }

   class Tester
   {
      public void Run(  )
      {
         try
         {
            Console.WriteLine( "Open file here" );
            double a = 0;
            double b = 5;
            Console.WriteLine( "{0} / {1} = {2}",
            a, b, DoDivide( a, b ) );
            Console.WriteLine(
            "This line may or may not print" );
         }

         // most derived exception type first
         catch ( System.DivideByZeroException e )
         {
            Console.WriteLine(
            "\nDivideByZeroException! Msg: {0}",
            e.Message );
            Console.WriteLine(
            "\nHelpLink: {0}\n", e.HelpLink );
         }
         // catch custom exception
         catch ( MyCustomException e )
         {
            Console.WriteLine(
            "\nMyCustomException! Msg: {0}",
            e.Message );
            Console.WriteLine(
            "\nHelpLink: {0}\n", e.HelpLink );
         }
         catch // catch any uncaught exceptions
         {
            Console.WriteLine(
            "Unknown exception caught" );
         }
         finally
         {
            Console.WriteLine( "Close file here." );
         }
      }

      // do the division if legal
      public double DoDivide( double a, double b )
      {
         if ( b == 0 )
         {
            DivideByZeroException e =
            new DivideByZeroException(  );
            e.HelpLink =
            "http://www.libertyassociates.com";
            throw e;
         }
         if ( a == 0 )
         {
            // create a custom exception instance
            MyCustomException e =
            new MyCustomException(
            "Can't have zero divisor" );
            e.HelpLink =
            "http://www.libertyassociates.com/NoZeroDivisor.htm";
            throw e;
         }
         return a / b;
      }

      static void Main(  )
      {
         Console.WriteLine( "Enter Main..." );
         Tester t = new Tester(  );
         t.Run(  );
         Console.WriteLine( "Exit Main..." );
      }
   }
}

The output looks like this:

    Enter Main...
    Open file here

    MyCustomException 
 
! Msg: Can't have zero divisor

    HelpLink: http://www.libertyassociates.com/NoZeroDivisor.htm

    Close file here.
    Exit Main...

MyCustomException is derived from System.Exception and consists of nothing more than a constructor that takes a string message that it passes to its base class.

The advantage of creating this custom exception class is that it better reflects the particular design of the Test class, in which it is not legal to have a zero divisor. Using the ArithmeticException rather than a custom exception would work as well, but it might confuse other programmers because a zero divisor wouldn't normally be considered an arithmetic error.

You are free, of course, to add methods and properties to your custom exception classes as needed.



 Python   SQL   Java   php   Perl 
 game development   web development   internet   *nix   graphics   hardware 
 telecommunications   C++ 
 Flash   Active Directory   Windows