Introduction
Enhanced Exception Handling is one of key features that is most prominently available in .Net both 2003 version and Whidbey versions of VB.Net.
This paper discusses the implementation of Custom Exception Handling using the existing features of VB.Net.
The Concept
The whole idea of having customized Exception Handling is centered around the fact that there needs to be a generic approach of catching and throwing Exceptions.
For implementing custom Exception Handling we need to derive the class CustomException from the system base class ApplicationException. In general, for customizing Exception Handling the following components are necessary:
1. A custom exception class which would host the exception thrown and can be thrown as a new exception.
2. A message class that would host all user - friendly Application messages that need to be displayed.
Implementation
The following are the steps that are required to implement custom exception for creation of the above mentioned components:
Step 1:
Define a project called Enumerators that would contain the definitions of all the Enumerators as the following:
Imports
System
Namespace CustomException_
'/ <summary>
'/ Severity level of Exception
'/ </summary>
Public Enum SeverityLevel
Fatal
Critical
Information
End Enum 'SeverityLevel
'/ <summary>
'/ Log level of Exception
'/ </summary>
Public Enum LogLevel
Debug
[Event]
End Enum 'LogLevel
End Namespace 'CustomException
- The Severity level determines the criticality of the error :
- The Loglevel determines whether an entry needs to be made in Log. Based on the log level chosen , entries can be made either in the Debug Log or System Event Log .
Step 2:
Add another project named CustomException. Add a reference of the Enumerators project. To the project add the following class deriving from ApplicationException:
Imports
System
Namespace CustomException
'/ <summary>
'/ Summary description for CustomException
'/ </summary>
Public Class CustomException Inherits ApplicationException
' private members
' defines the severity level of the Exception
Private severityLevelOfException As SeverityLevel
' defines the logLevel of the Exception
Private logLevelOfException As LogLevel
' System Exception that is thrown
Private innerException As Exception
' Custom Message
Private customMessage As String
'/ <summary>
'/ Public accessor of customMessage
'/ </summary>
Public Property CustomMessage() As String
Get
Return Me.customMessage
End Get
Set(ByVal Value As String)
Me.customMessage = value
End Set
End Property
'/ Standard default Constructor
'/ </summary>
Public Sub New()
End Sub 'New
'/ <summary>
'/ Constructor with parameters
'/ </summary>
'/ <param name="severityLevel"></param>
'/ <param name="logLevel"></param>
'/ <param name="exception"></param>
'/ <param name="customMessage"></param>
Public Sub New(ByVal severityLevel As SeverityLevel, ByVal logLevel As LogLevel, ByVal exception As Exception, ByVal customMessage As String)Me.severityLevelOfException = severityLevel
Me.logLevelOfException = logLevel
Me.innerException = exception
Me.customMessage = customMessage
End Sub 'New
End Class 'CustomException
End Namespace 'CustomException
One advantage of creating a custom Exception class is that the Constructor can be enabled to writing to a Log on instantiation of the CustomException Object using TraceListeners. The entry to the log would be based on the logLevel. This would force - write an entry each time the custom Exception is thrown.
Thus we have a customException which could be thrown in the catch-handlers of system-defined exceptions.
Step 3:
For implementing the CustomMessage component , create an Exception.resx File that would host the error string and the corresponding message string as key-value pair.
Ex. "Test", "Testing Error"
Step 4:
Add to project a CustomMessage.cs class File. This File would look in the following way:
Imports
System
Imports System.Globalization
Imports System.Threading
Imports System.Resources
Imports System.Reflection
Namespace CustomException
'/ <summary>
'/ Summary description for CustomMessage.
'/ </summary>
Public Class CustomMessage
Public Sub New()
End Sub 'New
Public Function GetString(ByVal key As String) As String
' Create a resource manager to retrieve resources.
Dim rm As New ResourceManager("Exceptions", [Assembly].GetExecutingAssembly())
' Get the culture of the currently executing thread.
' The value of ci will determine the culture of
' the resources that the resource manager retrieves.
Dim ci As CultureInfo = Thread.CurrentThread.CurrentCulture
' Retrieve the value of the string resource and return it
Dim str As [String] = rm.GetString(key, ci)
Return str
End Function 'GetString
End Class 'CustomMessage
End Namespace 'CustomException
The GetString() of the CustomMessage class is used to retrieve the value string corresponding to the key passed as parameter from the Exceptions resource File.
Usage
a) Add to existing Solution a Test Windows Applications Project.
b) Add the References to both the CustomException and the Enumerators projects.
c) Write a function which would throw a system exception , encapsulated in a try-catch block as follows :
Private Sub Updater()
Try
Dim i As Integer = 0
Dim j As Integer = 8
Dim k As Integer = j / i
Catch ex As Exception
Dim severityLevel As SeverityLevel = SeverityLevel.Critical
Dim logLevel As LogLevel = LogLevel.Debug
Dim customMessage As New CustomMessage
Throw New CustomException.CustomException(severityLevel, logLevel, ex.InnerException, customMessage.GetString("Test"))
End Try
d) In the Catch Block , re-throw the Exception as a CustomException.
e) On a button_click event handler add the following code :
Private Sub buttonTest_Click(ByVal sender As Object, ByVal e As System.EventArgs)
Try
Me.Updater()
Catch ce As CustomException.CustomException
MessageBox.Show(ce.CustomMessage)
End Try
End Sub 'buttonTest_Click
Conclusion
The above is one of the several methods of implementing Custom Exceptions in VB.Net. Another method would be using Application Blocks. Yet another method would be specifically defining all the Application Exceptions as separate classes and using them.
NOTE: THIS ARTICLE IS CONVERTED FROM C# TO VB.NET USING A CONVERSION TOOL. ORIGINAL ARTICLE CAN BE FOUND ON C# CORNER (WWW.C-SHARPCORNER.COM).