User-Defined Exception Classes
In many cases, you can use existing exception classes from the .NET Framework Class Library to indicate exceptions that occur in your programs. However, in some cases, you might wish to create new exception classes specific to the problems that occur in your programs. User-defined exception classes should derive directly or indirectly from class ApplicationException of namespace System.
|
Figures 12.6 and 12.7 demonstrate a user-defined exception class. Class NegativeNumberException (Fig. 12.6) is a user-defined exception class representing exceptions that occur when a program performs an illegal operation on a negative number, such as attempting to calculate its square root.
Figure 12.6. ApplicationException derived class thrown when a program performs an illegal operation on a negative number.
(This item is displayed on page 588 in the print version)
|
1 // Fig. 12.6: NegativeNumberException.cs 2 // NegativeNumberException represents exceptions caused by 3 // illegal operations performed on negative numbers. 4 using System; 5 6 namespace SquareRootTest 7 { 8 class NegativeNumberException : ApplicationException 9 { 10 // default constructor 11 public NegativeNumberException() 12 : base( "Illegal operation for a negative number" ) 13 { 14 // empty body 15 } // end default constructor 16 17 // constructor for customizing error message 18 public NegativeNumberException( string messageValue ) 19 : base( messageValue ) 20 { 21 // empty body 22 } // end one-argument constructor 23 24 // constructor for customizing the exception's error 25 // message and specifying the InnerException object 26 public NegativeNumberException( string messageValue, 27 Exception inner ) 28 : base( messageValue, inner ) 29 { 30 // empty body 31 } // end two-argument constructor 32 } // end class NegativeNumberException 33 } // end namespace SquareRootTest |
Figure 12.7. SquareRootForm class throws an exception if an error occurs when calculating the square root.
(This item is displayed on pages 589 - 590 in the print version)
|
1 // Fig. 12.7: SquareRootTest.cs 2 // Demonstrating a user-defined exception class. 3 using System; 4 using System.Windows.Forms; 5 6 namespace SquareRootTest 7 { 8 public partial class SquareRootForm : Form 9 { 10 public SquareRootForm() 11 { 12 InitializeComponent(); 13 } // end constructor 14 15 // computes square root of parameter; throws 16 // NegativeNumberException if parameter is negative 17 public double SquareRoot( double value ) 18 { 19 // if negative operand, throw NegativeNumberException 20 if ( value < 0 ) 21 throw new NegativeNumberException( 22 "Square root of negative number not permitted" ); 23 else 24 return Math.Sqrt( value ); // compute square root 25 } // end method SquareRoot 26 27 // obtain user input, convert to double, calculate square root 28 private void SquareRootButton_Click( object sender, EventArgs e ) 29 { 30 OutputLabel.Text = ""; // clear OutputLabel 31 32 // catch any NegativeNumberException thrown 33 try 34 { 35 double result = 36 SquareRoot( Convert.ToDouble( InputTextBox.Text ) ); 37 38 OutputLabel.Text = result.ToString(); 39 } // end try 40 catch ( FormatException formatExceptionParameter ) 41 { 42 MessageBox.Show( formatExceptionParameter.Message, 43 "Invalid Number Format", MessageBoxButtons.OK, 44 MessageBoxIcon.Error ); 45 } // end catch 46 catch ( NegativeNumberException 47 negativeNumberExceptionParameter ) 48 { 49 MessageBox.Show( negativeNumberExceptionParameter.Message, 50 "Invalid Operation", MessageBoxButtons.OK, 51 MessageBoxIcon.Error ); 52 } // end catch 53 } // end method SquareRootButton_Click 54 } // end class SquareRootForm 55 } // end namespace SquareRootTest (a) (b) (c) (d) |
According to "Best Practices for Handling Exceptions [C#]," user-defined exceptions should extend class ApplicationException, have a class name that ends with "Exception" and define three constructors: a parameterless constructor; a constructor that receives a string argument (the error message); and a constructor that receives a string argument and an Exception argument (the error message and the inner exception object). Defining these three constructors makes your exception class more flexible, allowing other programmers to easily use and extend it.
NegativeNumberExceptions most frequently occur during arithmetic operations, so it seems logical to derive class NegativeNumberException from class ArithmeticException. However, class ArithmeticException derives from class SystemExceptionthe category of exceptions thrown by the CLR. Recall that user-defined exception classes should inherit from ApplicationException rather than SystemException.
Class SquareRootForm (Fig. 12.7) demonstrates our user-defined exception class. The application enables the user to input a numeric value, then invokes method SquareRoot (lines 1725) to calculate the square root of that value. To perform this calculation, SquareRoot invokes class Math's Sqrt method, which receives a double value as its argument. Normally, if the argument is negative, method Sqrt returns NaN. In this program, we would like to prevent the user from calculating the square root of a negative number. If the numeric value that the user enters is negative, method SquareRoot throws a NegativeNumberException (lines 2122). Otherwise, SquareRoot invokes class Math's method Sqrt to compute the square root (line 24).
When the user inputs a value and clicks the Square Root button, the program invokes event handler SquareRootButton_Click (lines 2853). The TRy statement (lines 3352) attempts to invoke SquareRoot using the value input by the user. If the user input is not a valid number, a FormatException occurs, and the catch block in lines 4045 processes the exception. If the user inputs a negative number, method SquareRoot throws a NegativeNumberException (lines 2122); the catch block in lines 4652 catches and handles this type of exception.