Exception Handling in C#

Environment: C#

Definition:
"EXCEPTION IS A RUNTIME ERROR WHICH ARISES BECAUSE OF ABNORMAL CONDITION IN A CODE SEQUENCE. "

In C# Exception is a class in the system namespace. An object of an exception is that describe the exceptional conditions occur in a code That means, we are catching an exception, creating an object of it, and then throwing it. C# supports exceptions in 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 took place. This makes them very suitable for library or system code, which can 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...catch statements. Code which may give rise to exceptions is enclosed in a try block, which is followed by one or more catch blocks. Well if you don't use try...catch, you could get errors like the following:

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 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" ) ; 

The output of the program 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
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.

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. 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.

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 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.

int a, b = 0 ;
Console.WriteLine( "My program starts" ) ;
try
{
   a = 10 / b;
}
catch ( Exception e)
{
   throw 
}
finally
{
   Console.WriteLine ( "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

Downloads

Download source - 1.49 Kb


Comments

  • Exception Handling in C Sharp

    Posted by dummyahuja on 11/23/2010 10:09am

    this is the nice example check another ref: http://www.mindstick.com/Articles/de21d4fc-c6ea-4ae8-91db-874b727e5e6c/

    Reply
  • !

    Posted by Legacy on 11/13/2002 12:00am

    Originally posted by: Goran Mitrovic

    Look at the Enum.Parse method... :)
    

    Reply
  • throws clause

    Posted by Legacy on 12/14/2001 12:00am

    Originally posted by: Sean

    One big difference between Java and C# on dealing with checked exception is that Java introduces keyword 'throws' in method declaration so that compiler can help determine if a specific exception should be handled or not. C#, however, does not provide such keyword, I would consider that as a big disadvantage.

    Reply
Leave a Comment
  • Your email address will not be published. All fields are required.

Top White Papers and Webcasts

  • Live Event Date: October 29, 2014 @ 11:00 a.m. ET / 8:00 a.m. PT Are you interested in building a cognitive application using the power of IBM Watson? Need a platform that provides speed and ease for rapidly deploying this application? Join Chris Madison, Watson Solution Architect, as he walks through the process of building a Watson powered application on IBM Bluemix. Chris will talk about the new Watson Services just released on IBM bluemix, but more importantly he will do a step by step cognitive …

  • Packaged application development teams frequently operate with limited testing environments due to time and labor constraints. By virtualizing the entire application stack, packaged application development teams can deliver business results faster, at higher quality, and with lower risk.

Most Popular Programming Stories

More for Developers

Latest Developer Headlines

RSS Feeds