An exception is a problem that arises
during the execution of a program. C# exception handling is built upon four keywords: try, catch, finally and throw.
- try: A try
block identifies a block of code for which particular exceptions will be
activated. It's followed by one or more catch blocks.
- catch:
A program catches an exception with an exception handler at the place in a
program where you want to handle the problem. The catch keyword indicates the
catching of an exception.
- finally:
The finally block is used to execute a given set of statements, whether an
exception is thrown or not thrown. For example, if you open a file, it must be
closed whether an exception is raised or not.
throw:
This keyword
is used to throw an exception explicitly.
This is done using a throw keyword.
Exception Classes in C#
C# exceptions are
represented by classes. The exception classes in C# are mainly directly or
indirectly derived from the System.Exception class. Some of
the exception classes derived from the System.Exception class are the System.ApplicationException and System.SystemExceptionclasses.
The System.ApplicationException class
supports exceptions generated by application programs. So the exceptions
defined by the programmers should derive from this class.
The System.SystemException class is the
base class for all predefined system exception.
Problem 1 # Write Normal Try
Catch Statement:
Solution #
try
{
// Write
Your Code
}
catch (Exception ex1)
{
//
Handle Your Exception Here
}
finally
{
//
Finally will execute whether exception occurs or not in code
// Write
your business requirement
}
Problem 2 # If I am throwing a DivideByZeroException from try block and I
have 2 Catch block first one with Exception class and second with DivideByZeroException exception class which will execute?
Solution # It will give error like below:

Image 1.
You can write your code like below:
try
{
throw new DivideByZeroException();
}
catch (DivideByZeroException ex1)
{
Console.WriteLine("In DivideByZeroException Catch Block");
}
catch (Exception ex)
{
Console.WriteLine("In Exception Catch Block");
}
finally
{
Console.WriteLine("Finally Block");
}
Output will be:

Image 2.
Problem 3 # can be having try
without Catch?
Solution # Yes but in this case I have to use finally
block like below
First if I don't use finally block then it will give
error:

Image 3.
If I use finally then I can use try without catch like
in below code:
try
{
// Write
Your Code
Console.WriteLine("In Try Block");
}
finally
{
//
Finally will execute whether exception occurs or not in code
// Write
your business requirement
Console.WriteLine("In Finally Block");
}
Output:

Image 4.
Problem 4 # If I write below code
then will exception will occur:
try
{
Console.WriteLine("In Try Block");
throw new DivideByZeroException();
}
catch (DivideByZeroException ex1)
{
Console.WriteLine("In DivideByZeroException Catch Block");
throw new DivideByZeroException();
}
catch (Exception ex)
{
Console.WriteLine("In Exception Catch Block");
throw new DivideByZeroException();
}
finally
{
Console.WriteLine("Finally Block");
}
Solution # Yes like in below
image.

Image 5.
Problem 5 # Difference between
Throw Exception and Throw Clause
Solution# See both in code:

Image 6.
That difference is the Stack Trace Information that gets sent with the
exception
"When you throw an exception using "throw ex" then you override the original stack
trace with a new stack trace that starts from the throwing method."
Throw
In Throw, the original
exception stack trace will be retained. To keep the original stack trace
information, the correct syntax is 'throw' without specifying an exception.
Throw ex
In Throw ex, the
original stack trace information will get override and you will lose the
original exception stack trace. I.e. 'throw ex' resets the stack trace.