C# finally Block

Introduction

The finally block in C# is used to execute a set of statements regardless of whether an exception is thrown or not. It is typically used for cleaning up resources, such as closing file handles, database connections, or releasing memory. The finally block always runs after the try and catch blocks, making it a reliable place to put cleanup code.

Syntax

try
{
    // Code that might throw an exception
}
catch (ExceptionType e)
{
    // Code to handle the exception
}
finally
{
    // Code that runs regardless of an exception
}

Example: Using finally to Clean Up Resources

Example 1: Closing a File Stream

using System;
using System.IO;

namespace FinallyBlockExample
{
    class Program
    {
        static void Main(string[] args)
        {
            StreamReader reader = null;
            try
            {
                reader = new StreamReader("example.txt");
                string content = reader.ReadToEnd();
                Console.WriteLine(content);
            }
            catch (FileNotFoundException ex)
            {
                Console.WriteLine("Exception caught: File not found.");
                Console.WriteLine($"Exception Message: {ex.Message}");
            }
            finally
            {
                if (reader != null)
                {
                    reader.Close();
                    Console.WriteLine("File stream closed.");
                }
            }
        }
    }
}

Output

Exception caught: File not found.
Exception Message: Could not find file 'example.txt'.
File stream closed.

Example 2: Releasing a Database Connection

using System;
using System.Data.SqlClient;

namespace FinallyBlockExample
{
    class Program
    {
        static void Main(string[] args)
        {
            SqlConnection connection = null;
            try
            {
                connection = new SqlConnection("your_connection_string");
                connection.Open();
                // Perform database operations
            }
            catch (SqlException ex)
            {
                Console.WriteLine("Exception caught: Database error.");
                Console.WriteLine($"Exception Message: {ex.Message}");
            }
            finally
            {
                if (connection != null && connection.State == System.Data.ConnectionState.Open)
                {
                    connection.Close();
                    Console.WriteLine("Database connection closed.");
                }
            }
        }
    }
}

Output

Exception caught: Database error.
Exception Message: [Error details]
Database connection closed.

Using finally without catch

You can use a finally block with a try block even if there is no catch block. This ensures that the finally block will execute regardless of whether an exception is thrown.

Example

using System;

namespace FinallyWithoutCatchExample
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("Inside try block.");
                // Simulate an exception
                throw new InvalidOperationException("An error occurred.");
            }
            finally
            {
                Console.WriteLine("Inside finally block.");
            }
        }
    }
}

Output

Inside try block.
Inside finally block.
Unhandled Exception: System.InvalidOperationException: An error occurred.

Practical Example: File Handling

Let’s create a practical example where we use a finally block to ensure a file stream is closed after reading from a file.

using System;
using System.IO;

namespace FileHandlingExample
{
    class Program
    {
        static void Main(string[] args)
        {
            StreamReader reader = null;
            try
            {
                reader = new StreamReader("example.txt");
                string content = reader.ReadToEnd();
                Console.WriteLine(content);
            }
            catch (FileNotFoundException ex)
            {
                Console.WriteLine("Exception caught: File not found.");
                Console.WriteLine($"Exception Message: {ex.Message}");
            }
            finally
            {
                if (reader != null)
                {
                    reader.Close();
                    Console.WriteLine("File stream closed.");
                }
            }
        }
    }
}

Output

[Contents of example.txt if found]
OR
Exception caught: File not found.
Exception Message: Could not find file 'example.txt'.
File stream closed.

Best Practices

1. Always Clean Up Resources: Use the finally block to ensure that resources like file handles, database connections, or network connections are always cleaned up, even if an exception occurs.
2. Avoid Returning from Finally: Do not return from a finally block, as it can hide exceptions and make your code harder to understand.
3. Keep It Simple: Keep the code inside the finally block simple and free of operations that might throw exceptions themselves.
4. Use using Statements: For managing resources, prefer using using statements, which automatically handle resource cleanup and make the code more readable.

Example: Using using Statement

using System;
using System.IO;

namespace UsingStatementExample
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                using (StreamReader reader = new StreamReader("example.txt"))
                {
                    string content = reader.ReadToEnd();
                    Console.WriteLine(content);
                }
            }
            catch (FileNotFoundException ex)
            {
                Console.WriteLine("Exception caught: File not found.");
                Console.WriteLine($"Exception Message: {ex.Message}");
            }
        }
    }
}

Output

[Contents of example.txt if found]
OR
Exception caught: File not found.
Exception Message: Could not find file 'example.txt'.

Conclusion

The finally block in C# is an essential tool for ensuring that code for cleaning up resources is always executed, regardless of whether an exception is thrown. By using try, catch, and finally blocks appropriately, you can write robust and reliable code that handles exceptions gracefully and maintains resource integrity.