❮ Csharp If Csharp Regular Expressions ❯

C# Exception Handling

An exception is a problem that occurs during the execution of a program. In C#, exceptions are responses to special situations that arise during the runtime of a program, such as attempting to divide by zero.

Exceptions provide a way to transfer 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 is followed by one or more catch blocks.
catch: The program catches exceptions with an exception handler. 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: When a problem occurs, the program throws an exception. This is done using the throw keyword.

Syntax

Suppose a block will raise an exception; a method catches exceptions using a combination of the try and catch keywords. The code within a try/catch block is referred to as 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 the try block raises multiple exceptions under different conditions.

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. The System.ApplicationException and System.SystemException classes are exceptions that are derived from the System.Exception class.

The System.ApplicationException class supports exceptions generated by application programs. Therefore, custom exceptions should be derived from this class.

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

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

Exception Class	Description
System.IO.IOException	Handles I/O errors.
System.IndexOutOfRangeException	Handles errors generated when a method refers to an out-of-range array index.
System.ArrayTypeMismatchException	Handles errors generated by type mismatches in arrays.
System.NullReferenceException	Handles errors generated from deferencing 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.

Exception Handling

C# provides structured exception handling using the try and catch blocks. Using these blocks, core program statements are separated from error-handling statements.

These error-handling blocks are implemented using the try, catch, and finally keywords. Below is an example that throws an exception when a division by zero occurs:

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

Creating User-Defined Exceptions

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

Throwing Objects

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

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

❮ Csharp If Csharp Regular Expressions ❯