Post
Ask Question

Custom Exception in C#

Introduction

Today I will inform you about custom exceptions and how to implement custom exceptions. But before diving into Custom exceptions, let's start with basic exception-handling blocks.

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 are activated. It is 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- A program throws an exception when a problem shows up. This is done using a throw keyword.

We have some basic built-in exceptions mentioned below.

Sr. No. Exception Class Description
1 System.IO.IOException Handles I/O errors.
2 System.IndexOutOfRangeException Handles errors generated when a method refers to an array index out of range.
3 System.ArrayTypeMismatchException Handles errors generated when type is mismatched with the array type.
4 System.NullReferenceException Handles errors generated from referencing a null object.
5 System.DivideByZeroException Handles errors generated from dividing a dividend with zero.
6 System.InvalidCastException Handles errors generated during typecasting.
7 System.OutOfMemoryException Handles errors generated from insufficient free memory.
8 System.StackOverflowException Handles errors generated from stack overflow.

Now come to Custom Exception handling.

Any class inherited from the Base Exception class is a Custom Exception class as an exception is raised from the Base class, so you need to pass an argument to the base class.

public class CustomExeption:Exception
{
    public CustomExeption(string msg):base(msg)
    {
        throw new Exception(msg);
    }
}

Let's see how to use this custom exception in the code. Here I was given two requirements for the divide method. 

  1. It gives an error when the denominator is 0, so I used the built-in exception here.
  2. It gives an error when the numerator is more than 1000, so I used a custom exception to raise the error here.
using System;

namespace CustomExceptionHandling
{
    class Program
    {
        static void Main(string[] args)
        {
            Divide(10, 2);
            Divide(10, 0);
            Divide(100000, 33);
            Console.ReadLine();
        }
        static void Divide(int a, int b)
        {
            try
            {
                Calculator c = new Calculator();
                c.Divide(a, b);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
            finally
            {
            }
        }
    }
    public class Calculator
    {
        // Requirement to make divide method 
        // 1)- give error on Den =0
        //2)- give error when numerator more than 1000
        public void Divide(int Num, int Den)
        {
            if (Den == 0)
            {
                throw new DivideByZeroException();
            }
            if (Num > 1000)
            {
                throw new CustomExeption("My New Custom Exception");
            }
            Console.WriteLine(Num / Den);
        }
    }
    public class CustomExeption : Exception
    {
        public CustomExeption(string msg) : base(msg)
        {
            throw new Exception(msg);
        }
    }
}

Conclusion

Exception Handling plays a vital role in writing efficient code and managing run time issues as we can't use the built-in exception at all places, so custom exceptions help us to achieve the desired requirements.


Similar Articles