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.

It gives an error when the denominator is 0, so I used the built-in exception here.
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.