Consider the following code listing:

using System;
class Program
{
static void Main()
{
try
{
Console.WriteLine(
"Hello. My name is Inigo Montoya.");
}
catch(Exception )
{
// .
}
catch
{
Console.WriteLine("UNEXPECTED EXCEPTION");
}
}
}

In C# 1.0, this code was perfectly valid. However, in C# 2.0 it results in a warning. Why is that?

An empty catch block (catch{ . }), compilesdown to CIL code that is the equivalent of catch(object ){ . }. Inother words, an empty catch block in C# is a catch block for any andall types that are thrown as exceptions. (Interestingly, C# doesn'tallow you to explicitly code catch(object ){ . }. Therefore, there isno means of catching a non-System.Exception-derived exception and havethe exception instance to scrutinize.)

It is perhaps surprising that catch(object ){. } is needed because C# doesn't allow you to throw an exception thatdoesn't derive from System.Exception. However, the same restrictiondoes not apply to other languages. C++, for example, can throw anobject of any type (whether derived from System.Exception or not). As aresult, in C# 1.0, the only way to ensure that all exceptions werecaught was to include an empty catch block.

In C# 2.0 the rules improved. Although it isstill possible for other languages to throw exceptions of any type, theCLR will wrap all exceptions that do not derive from System.Exceptioninto a System.Runtime.CompilerServices.RuntimeWrappedException object,which does derive from System.Exception. In other words, allexceptions, whether System.Exception-derived or not when they arethrown, will be caught in C# 2.0 code by a catch(Exception ){ . }block.

Therefore, if you follow a catch(Exception ){. } block by an empty exception block (as shown in the initial codelisting), the empty exception block will never execute. All exceptionswill be wrapped in the RuntimeWrappedException if they do not derivefrom System.Exception already and therefore be caught bycatch(Exception ){ . }.

One more thing to note: If you wish your codeto behave as it did with C# 1.0 in this area, you can add theRuntimeCompatibility assembly attribute as in:

[assembly:System.Runtime.CompilerServices.RuntimeCompatibility(WrapNonExceptionThrows = false)]

This will no longer produce the warning sinceit will also turn off the new CLR 2.0 behavior in whichnon-System.Exception-derived exceptions are wrapped withRuntimeWrappedException.

STEP1: Create my own exception class wichcontains extra properties (sender and details). This class also contains aShowError method that loads a form that will show the error message(s). TheToString is overridden so it can show my extra added information. 

//——————————————————————-
//
// Author : Loek van den Ouweland
// EMail  : lvdo@in2net.nl
// Creation date : July 2003
//
//——————————————————————-
using System;
using System.Windows.Forms;

namespace LootAtThisError
{
    public class LookException : ApplicationException
    {
        private string mSender;
        private string mDetails;
        publicLookException (string message, Exception ex, string sender, string details) : base (message,ex)
        {
            mSender=sender;
            mDetails=details;
        } 
        public string Sender
        {
            get{return mSender;}
        }
        public string Details
        {
            get{return mDetails;}
        }
             
        public void ShowError()
        {
            FExceptionfe=new FException(this);
            fe.ShowDialog();
        }

        public override string ToString()
        {
            string errortext="Message: " + this.Message + Environment.NewLine +
            "Sender : " + mSender + Environment.NewLine +
            "Details: " + mDetails + Environment.NewLine;

            return errortext;
        } 
    }

}

STEP2: The first error that will appear isalways of type: Exception. Just catch this bad boy and throw your own:

stringsql="this will certainly raise an arror";
.
.
catch (Exception ex)
{
   thrownewLookException (ex.Message,ex,ex.Source,sql);
}

STEP3: Just catch and rethrow your error asmany times as you want. These are LookExceptions:

catch(LookException ex)
{
   thrownewLookException ("myfriendly error message",ex,"it happened here","extra detailslike ID's");
}

STEP4: At last, i.e. in your presentationlayer, just catch the LookExceptionand show the error:

catch (LookExceptionex)
{
    ex.ShowError();
}

catch(Exception ex)
{
  // also: always catch a default Exception just to make sure no-oneescapes!
}

STEP5: Create a form that's capable of showingthe error. To show the error with all it's innerexceptions, pass the exceptionto the form (store it in mException) and do something like this:

private voidFException_Load(object sender,System.EventArgs e)
{
    txtMessage.Text=mException.Message;
    Exception inex=mException;
    while (inex!=null)
   {
        txtDetails.Text+=inex.ToString() + Environment.NewLine;
        txtDetails.Text+=Environment.NewLine + "<*==—————————==*>" +Environment.NewLine;
       inex=inex.InnerException;
   }
}

CONCLUSION: The trick here is that every timeyou throw an error, you can pass the 'just catched' error along with it. Finallyshow the exception plus all innerexceptions by calling their ToString-functions.Happy catching!

Exceptions are errors that may occur duringthe run-time of a program. Exception handling, thus, becomes anintegral part of programming. In C#, exceptions are handled via theException base class. You can also create your own Exception class but,which will, necessarily, derive from the base, inbuilt Exception class.

An exception is, for example, a "divide byzero operation", which will result in a faulty or a needless result andhence, needs to be handled in a program. An exception can also be,"IndexOutOfBounds", which arises out when your program tries to accessa non-existent element in an array say, 101, in an array of max size100. There are many such inbuilt exceptions that are handled by theException base class but, since logic is about possibilities, thepossibility of an unhandled exception may arise and to know how tocreate your own exception class to handle such a calamity is thepurpose of this article.

The following is a program that defines my own Exception class.

using System;
public class MyException:Exception
{
public string s;
public MyException():base()
{
s=null;
}
public MyException(string message):base()
{
s=message.ToString();
}
public MyException(string message,Exception myNew):base(message,myNew)
{
s=message.ToString();// Stores new exception message into class member s
}
public static void Test()
{
string str,stringmessage;
bool flag=false;
stringmessage=null;
char ch=' ';
int i=0;
Console.Write("Please enter some string (less than 27 characters) – ");
str=Console.ReadLine();
try{
ch=str[i];
while (flag==false)
{
if (ch=='\r')
{
flag=true;
}
else{
ch=str[i];
i++;
}
}
}
catch(Exception e){
flag=true;
}

if (i>27)
{
stringmessage="You cannot enter more than 27 characters !";
throw new MyException(stringmessage);
}
}
public static void Main()
{
try
{
Test();
}
catch(MyException e)
{
Console.WriteLine(e.s);
}
}
}

The above program creates a new exceptionclass called MyException, which derives from the base Exception class.The class has three constructors – one, default and two overloadedconstructors. The intention is simple – to be able to overload aconstructor of the base class, the base class' default or existingconstructors must be implemented in the deriving class and thenoverload the relevant constructor. But, the real purpose of the classis to handle an exception – if the user enters more than 27 characters,then a message prompting the user of the error is to be displayed.Although, this is not really an exception, such an instance is actuallycalled Validation of data but, for want of an example, such anoccurrence has been used for exception handling. The new exceptionMyException is thrown from the Test() method and the message – "Youcannot enter more than 27 characters !" – is passed to the class, whichis retrieved by the catch block in the Main() method !

Debugging GUI applications for me mostlyconsists of printing out debug statements in the form of a dialog boxwith some text. While this technique was helpful for small to mediumsize apps I find writing large apps with a dialog box popping up afterevery other statement is counterproductive. With this in mind, I setout to find a better method for displaying debug statements duringruntime. Enter C#.

C# solves three problems I faced whendesigning the useful and scalable debugging system. These problemsexist either in Java, C/C++, or both (my main programming languages).

1. Not having very much meta-information (e.g. line number, method name, etc.)
2. Having to add and remove debug statements whenever the debug focus shifts
3. Having the debug statements compiled into the program affecting performance

Ok, discussing the solution for these problemsin order we’ll start with number one. Basically a few classes from theSystem.Reflection and System.Diagnostics namespaces solve this problem.Using the System.Diagnostics.StackFrame class the call stack can beexplored and stack details such as what is on the stack level above thecurrent one, what line is a function being called from, etc. And withthe System.Reflection classes the names of functions, namespaces,variable types, etc., can be ascertained. Applying all this to theproblem at hand here’s some code that retrieves the file name, linenumber, and method name of the function that called it.

// create the stack frame for the function that called this function
StackFrame sf = new StackFrame( 1, true );

// save the method name
string methodName = sf.GetMethod().ToString();

// save the file name
string fileName = sf.GetFileName();

// save the line number
int lineNumber = sf.GetFileLineNumber();

Moving right along to problem number two let’sdiscuss how to selectively debug different sections of a program duringruntime. Number two ties in with number one in that information fromnumber one will help us filter debug statements from being displayed.For this example we’ll filter by namespace. So say that you havefifteen namespaces in your program and right now you only want todisplay debug statements from one all you would have to do is tell thedebug class only allow that one namespace to display debug statements.Simple enough. Here’s some code.

// create the namespaces hashtable
namespaces = new Hashtable();

// get the assembly of this class
Assembly a = Assembly.GetAssembly( new Debug().GetType() );

// now cycle through each type and gather up all the namespaces
foreach( Type type in a.GetTypes() )
{
// check if the namespace is already in our table
if( ! namespaces.Contains( type.Namespace ) )
namespaces.Add( type.Namespace, true );
}

The above code will create a Hashtable objectcontaining all the namespaces in the same assembly as the Debug classof which this code is a part. Of course, this is only half of thesolution so here is the actual filtering code.
Continues…

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 problemthat needs to be dealt with right away. This tutorial requires that youhave a basic understanding of C# (or Java) exceptions and that you haveused them a few times in your code.

The purpose of this tutorial is to explainfirstly how you would go about creating your own set of exceptions totrap error conditions that could occur in your code or library, foryour own benefit or for the benefit of another developer using yourlibrary. 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
Everyexception that is defined within the .NET framework derives from aclass 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 occurfrom 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 Socketclass 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 characteristicis that you can set up an exception stack to trap errors, starting fromthe 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 classicobject inheritance example ofObject->Vehicle->MotorCar->Ferrari. Can you see how each exception object has a direct connection to the physical object itraises an error for? Examine the source code in the CheckCar class andyou will see the order that each exception is trapped.

Creating your own Exceptions in C#
Thisbecomes a very useful tool when you start creating libraries of code tobe used in your application. Each library which is built to perform aspecific task, should have it’s own set of exceptions that alert thedeveloper of error conditions that can arise when the library is used.<br /><em>Continues…</em><br /><br /><!–nextpage–>

For example, if you have a library thatparses a string, but cannot accept the character ‘&’. You wouldthen create an exception called BadCharacterException which will bethrown each time the application tries to parse a string containing the’&’ character.
Continues…

Definition:"EXCEPTION IS A RUNTIME ERROR WHICH ARISES BECAUSE OF ABNORMALCONDITION INA CODE SEQUENCE. " In C# Exception is a class in the systemnamespace. An object of an exception is that describe the exceptionalconditions occur in a code That means, we are catching an exception,creating an object of it, and then throwing it. C# supports exceptionsin a very much the same way as Java and C++.

Before going into detail, I must say the usefulness of knowing and performing exception handling :

? They cannot be ignored, as if calling code does not handle the error, it causes program termination.
? They do not need to be to be handled at the point where error tookplace. This makes them very suitable for library or system code, whichcan signal an error and leave us to handle it
? They can be used when passing back a return value cannot be used.

Exceptions are handled by using try?catchstatements. Code which may give rise to exceptions is enclosed in a tryblock , which is followed by one or more catch blocks. Well if we don'twrite like such we get errors like as follows :

class A {
static void Main() {
catch {
}
}
}

TEMP.cs(3,5): error CS1003: Syntax error, 'try' expected

class A {
static void Main() {
finally {
}
}
}

TEMP.cs(3,5): error CS1003: Syntax error, 'try' expected

class A {
static void Main() {
try {
}
}
}

TEMP.cs(6,3): error CS1524: Expected catch or finally

The try block contains the code segmentexpected to raise an exception. This block is executed until anexception is thrown The catch block contains the exception handler.This block catches the exception and executes the code written in theblock. If we do not know what kind of exception is going to be thrownwe can simply omit the type of exception. We can collect it inException object as shown in the following program:

int a, b = 0 ;
Console.WriteLine( "My program starts " ) ;
try
{
a = 10 / b;
}
catch ( Exception e )
{
Console.WriteLine ( e ) ;
}
Console.WriteLine ( "Remaining program" ) ;

The output of the program is:

My program starts
System.DivideByZeroException: Attempted to divide by zero.atConsoleApplication4.Class1.Main(String[] args) in d:\dont delete\c#(csharp)\swapna\programs\consoleapplication4\consoleapplication4\class1.cs:line51
Remaining program

The exception 'Divide by zero' was caught, butthe execution of the program did not stop. There are a number ofexception classes provided by C#, all of which inherit from theSystem.Exception class. Following are some common exception classes.

Exception Class	Cause
SystemException	A failed run-time check;used as a base class for other.
AccessException	Failure to access a type member, such as a method or field.
ArgumentException	An argument to a method was invalid.
ArgumentNullException	A null argument was passed to a method that doesn't accept it.
ArgumentOutOfRangeException	Argument value is out of range.
ArithmeticException	Arithmetic over – or underflow has occurred.
ArrayTypeMismatchException	Attempt to store the wrong type of object in an array.
BadImageFormatException	Image is in the wrong format.
CoreException	Base class for exceptions thrown by the runtime.
DivideByZeroException	An attempt was made to divide by zero.
FormatException	The format of an argument is wrong.
IndexOutOfRangeException	An array index is out of bounds.
InvalidCastExpression	An attempt was made to cast to an invalid class.
InvalidOperationException	A method was called at an invalid time.
MissingMemberException	An invalid version of a DLL was accessed.
NotFiniteNumberException	A number is not valid.
NotSupportedException	Indicates sthat a method is not implemented by a class.
NullReferenceException	Attempt to use an unassigned reference.
OutOfMemoryException	Not enough memory to continue execution.
StackOverflowException	A stack has overflown.

The finally block is used to do all the cleanup code. It does not support the error message, but all the codecontained in the finally block is executed after the exception israised. We can use this block along with try-catch and only with catchtoo.

The finally block is executed even if theerror is raised. Control is always passed to the finally blockregardless of how the try blocks exits.

This is shown in the following example:

int a, b = 0 ;
Console.WriteLine( "My program starts" ) ;
try
{
a = 10 / b;
}
catch ( InvalidOperationException e )
{
Console.WriteLine ( e ) ;
}
catch ( DivideByZeroException e)
{
Console.WriteLine ( e ) ;
}
finally
{
Console.WriteLine ( "finally" ) ;
}
Console.WriteLine ( "Remaining program" ) ;

The output here is:

My program starts
System.DivideByZeroException: Attempted to divide by zero.
at ConsoleApplication4.Class1.Main(String[] args) in d:\dont delete\c# (c sharp)\swapna\programs\consoleapplication4\consoleapplication4\class1.cs:line 51
finally
Remaining program

But then what's the difference? We could have written
Console.WriteLine ("finally");
after the catch block, and not write the finally block at all. Writingfinally did not make much of a difference. Anyway the code writtenafter catch gets executed.
The answer to this is not clear in this program.
It will be clear when we see the try-finally and the throw statement.
Consider the following code snippet

int a, b
= 0 ; />Console.WriteLine( "My program starts" )
try
{
a = 10 / b;
}
finally
{
Console.WriteLine ( "finally" ) ;
}
Console.WriteLine ( "Remaining program" ) ;

Here the output is

My program starts
Exception occurred: System.DivideByZeroException: Attempted to divideby zero.at ConsoleApplication4.Class1.Main(String[] args) in d:\dontdelete\c# (csharp)\swapna\programs\consoleapplication4\consoleapplication4\class1.cs:line51
finally

Note that "Remaining program" is not printed out. Only "finally" is printed which is written in the finally block.

The throw statement throws an exception. Athrow statement with an expression throws the exception produced byevaluating the expression. A throw statement with no expression is usedin the catch block. It re-throws the exception that is currently beinghandled by the catch block.

Consider the following program:

int a, b = 0 ;
Console.WriteLine( "My program starts" ) ;
try
{
a = 10 / b;
}
catch ( Exception e)
{
throw
}
finally
{
Console.WriteLine ( "finally" ) ;
}

The output here is:

My program starts
Exception occurred: System.DivideByZeroException: Attempted to divideby zero.at ConsoleApplication4.Class1.Main(String[] args) in d:\dontdelete\c#(csharp)\swapna\programs\consoleapplication4\consoleapplication4\class1.cs:line55
finally

This shows that the exception is re-thrown.Whatever is written in finally is executed and the program terminates.Note again that "Remaining program" is not printed.