Csharp Exception Handling

C# Exception Handling

Exceptions are problems that occur during program execution. In C#, exceptions are responses to special situations that arise at runtime, such as attempting to divide by zero.

Exceptions provide a way to transfer program control from one part of a program to another. 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. For example, if you open a file, it must be closed whether an exception is raised or not.
throw: A problem arises when a program throws an exception. This is done using the throw keyword.

Assume a block raises an exception. A method catches the exception using the try and catch keywords. The code inside the try/catch block is the protected code, and the syntax for using try/catch looks like this:

try
{
    // Statements that may cause an exception
}
catch( ExceptionName e1 )
{
    // Error handling code
}
catch( ExceptionName e2 )
{
    // Error handling code
}
catch( ExceptionName eN )
{
    // Error handling code
}
finally
{
    // Statements to be executed
}

You can list multiple catch statements to catch different types of exceptions in case your try block generates more than one exception in different scenarios.

C# exceptions are represented by classes. The exception classes in C# are mainly derived directly or indirectly from the class System.Exception. The classes System.ApplicationException and System.SystemException are derived from System.Exception.

The class System.ApplicationException supports the exceptions generated by application programs. Hence the exceptions defined by the programmers should be derived from this class.

The class System.SystemException is the base class for all predefined system exceptions.

The following table lists some of the predefined exception classes derived from System.SystemException:

Exception Class	Description
System.IO.IOException	Handles I/O errors.
System.IndexOutOfRangeException	Handles errors generated when a method refers to an array index out of range.
System.ArrayTypeMismatchException	Handles errors generated when type mismatch for an array.
System.NullReferenceException	Handles errors generated from referencing a null object.
System.DivideByZeroException	Handles errors generated from dividing by zero.
System.InvalidCastException	Handles errors generated during typecasting.
System.OutOfMemoryException	Handles errors generated from insufficient free memory.
System.StackOverflowException	Handles errors generated from stack overflow.

C# provides a structured exception handling solution by using the try and catch blocks. Using these blocks, you can keep the main program statements separate from the error handling statements.

These error handling blocks are implemented using the try, catch, and finally keywords. The following is an example of throwing an exception when dividing by zero:

Example

using System;

namespace ErrorHandlingApplication
{
    class DivNumbers
    {
        int result;

        DivNumbers()
        {
            result = 0;
        }

        public void division(int num1, int num2)
        {
            try
            {
                result = num1 / num2;
            }
            catch (DivideByZeroException e)
            {
                Console.WriteLine("Exception caught: {0}", e);
            }
            finally
            {
                Console.WriteLine("Result: {0}", result);
            }
        }

        static void Main(string[] args)
        {
            DivNumbers d = new DivNumbers();
            d.division(25, 0);
            Console.ReadKey();
        }
    }
}

When the above code is compiled and executed, it produces the following result:

Exception caught: System.DivideByZeroException: Attempted to divide by zero. at ...Result: 0

You can also define your own exceptions. User-defined exception classes are derived from the ApplicationException class. The following example demonstrates this:

Example

using System;

namespace UserDefinedException
{
    class TestTemperature
    {
        static void Main(string[] args)
        {
            Temperature temp = new Temperature();
            try
            {
                temp.showTemp();
            }
            catch (TempIsZeroException e)
            {
                Console.WriteLine("TempIsZeroException: {0}", e.Message);
            }
            Console.ReadKey();
        }
    }
}

public class TempIsZeroException: ApplicationException
{
    public TempIsZeroException(string message): base(message)
    {
    }
}

public class Temperature
{
    int temperature = 0;

    public void showTemp()
    {
        if (temperature == 0)
        {
            throw (new TempIsZeroException("Zero Temperature found"));
        }
        else
        {
            Console.WriteLine("Temperature: {0}", temperature);
        }
    }
}

When the above code is compiled and executed, it produces the following result:

TempIsZeroException: Zero Temperature found

You can throw an object if it is directly or indirectly derived from the System.Exception class. You can use a throw statement to throw the current object in the catch block as shown below:

Catch(Exception e){ ... Throw e }

YouTip