The try block contains the code segment expected to raise an exception. This block is executed until an exception is thrown The catch block contains the exception handler. This block catches the exception and executes the code written in the block. If we do not know what kind of exception is going to be thrown we can simply omit the type of exception. We can collect it in Exception 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" ) ; 

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
Remaining program

The exception 'Divide by zero' was caught, but the execution of the program did not stop. There are a number of exception classes provided by C#, all of which inherit from the System.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 clean up code. It does not support the error message, but all the code contained in the finally block is executed after the exception is raised. We can use this block along with try-catch and only with catch too.

The finally block is executed even if the error is raised. Control is always passed to the finally block regardless 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" ) ; 

My program starts
System.DivideByZeroException: Attempted to divide by zero.
at ConsoleApplication4.Class1.Main(String[] args) in d:\dont delete\c# (c sha rp)\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. Writing finally did not make much of a difference. Anyway the code written after 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" ) ; 

My program starts
Exception occurred: 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

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. A throw statement with an expression throws the exception produced by evaluating the expression. A throw statement with no expression is used in the catch block. It re-throws the exception that is currently being handled 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" ) ; 
}

My program starts
Exception occurred: System.DivideByZeroException: Attempted to divide by zero.at ConsoleApplication4.Class1.Main(String[] args) in d:\dont delete\c# (csharp)\swapna\programs\consoleapplication4\consoleapplication4\class1.cs:line 55
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.