Exception in Finally Block

using System;
namespace ExceptioninFinallyblock
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                FinallyBlock(); // Calling the method
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
       
        public static void FinallyBlock()
        {
            try
            {
            }
            catch
            {
            }
            finally
            {
                Console.WriteLine("This line will be executed"); // Statement before exception occurs

                try
                {
                    int result = Convert.ToInt32("THREE"); // Here an exception will occur
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }
    }
}

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;
namespace ExceptioninFinallyblock
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                FinallyBlock(); // Calling the method
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }

        public static void FinallyBlock()
        {
            try
            {
            }
            catch
            {
            }
            finally
            {
                Console.WriteLine("This line will be executed"); // Statement before exception occurs
                try
                {
                    int result = Convert.ToInt32("THREE"); // Convert to integer
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
                Console.WriteLine("This line will Not be executed"); // Statement after exception occurs
            }
        }
    }
}

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 occurs is not printed because at the point where the Exception occurs, 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 final block by the following code.

using System;
namespace ExceptioninFinallyblock
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                FinallyBlock(); // Calling the 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 final 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.