Exception in Finally Block

Question: What happens if a finally block throws an exception?

Or

How to handle exceptions that occur in a finally block?

Answer: Three things happen.



Let's understand with an example

Step 1: first we will create a console application named ExceptioninFinallyblock.



Step 2: Now here we will create a method named FinallyBlock and include a try, catch and finally block.

Now we write some code within the finally block that would cause an exception to occur with the following code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ExceptioninFinallyblock
{
    class Program
    {
        static void Main(string[] args)
        {
            FinallyBlock();//calling method
        }

        public static void FinallyBlock()
       {
           try
           {

           }
           catch
           {

           }
           finally
           {
               int result = Convert.ToInt32("THREE");//convert to integer
           }
       }
    }
}

Step 3: So notice that at the higher level where we called the FinallyBlock() the method doesn't have any exception handling mechanism there. When we run the program the application will terminate with the exception that occurs in the finally block.



Now we will provide an exception handling mechanism at the higher level in the Main() method where we are actually calling the FinallyBlock() method. So we are using the exception handling mechanism.

Here we have the opportunity to handle the exception that occurs in the finally block of the FinallyBlock() method. Here we write an exception message to the console with the following code.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ExceptioninFinallyblock
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                FinallyBlock();//calling method
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        public static void FinallyBlock()
       {
           try
           {

           }
           catch
           {

           }
           finally
           {
               int result = Convert.ToInt32("THREE");//convert to integer
           }
       }
    }
}

Now run the program. We will see that the application does not crash since we have an exception handling mechanism at a higher level, we have the opportunity to handle the exception.



Step 4: So what is the second point.



So at the finally block where the exception is thrown let's include a Console.WriteLine() statement. That line is present before the exception occurs, so this piece of code will execute.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ExceptioninFinallyblock
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                FinallyBlock();//calling method
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        public static void FinallyBlock()
       {
           try
           {

           }
           catch
           {

           }
           finally
           {
               Console.WriteLine("This line wil be executed");//statement before exception occur
               int result = Convert.ToInt32("THREE");//here will be exception occur
           }
       }
    }
}

Now we will include one Console.WriteLine() statement after the line where the exception occurs so the execution will stop at this line and the Console.WriteLine() statement will not be executed.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ExceptioninFinallyblock
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                FinallyBlock();//calling method
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        public static void FinallyBlock()
       {
           try
           {

           }
           catch
           {

           }
           finally
           {
               Console.WriteLine("This line wil be executed");//statement before exception occur
               int result = Convert.ToInt32("THREE");//convert to integer
               Console.WriteLine("This line wil Not be executed");//statement after exception occur
           }
       }
    }
}

Now let's run and see the output, the first line is printed that is written before the exception occurs.

And the second line that is written after the exception occur is not printed because at the point where the Exception occured the execution will stop and the statements after the exception will not be executed.





So the "finally" block execution stops at the point where the exception is thrown.

Step 5: Now the third point.



Let's understand with an example.

Now we throw an exception in the try block and in the finally block by the following code.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ExceptioninFinallyblock
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                FinallyBlock();//calling method
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        public static void FinallyBlock()
       {
           try
           {
               throw new Exception("Try Block Exception");

           }
           finally
           {
               throw new Exception("Finally Block Exception");

           }
       }
    }
}

Now run the program so we are able to handle the exception that are occurs in the finally block. But what about the exception that occurs in the try block?


So we know that whether the exception occurs or not, the finally will execute, it is guaranteed to execute.

Now this exception will occur in the try block and we are not handling the exception within this method.

And there is another exception occurring within the finally block, so as a result the original exception that occurred in the try block is lost. So the third point it is.