What is a 'finally' Block?

In structured exception handling, the try block lets you run code that might fail, and the catch block lets you handle the failure. But what if you have code that needs to run no matter what? For example, what if you need to close a file or release a network connection, regardless of whether the operation succeeded or failed?

This is the exact purpose of the finally block.

Guaranteed Execution

The finally block is an optional part of a try-catch statement that provides a mechanism for guaranteed cleanup. The code inside a finally block is always executed, after the try and any catch blocks have finished. This guarantee holds true in all of the following scenarios:

1. No exception occurs: The try block completes successfully. The finally block runs.
2. An exception is caught: An exception is thrown in the try block and is handled by a catch block. The finally block runs after the catch block.
3. An exception is not caught: An exception is thrown in the try block, but there is no matching catch block. The finally block still runs before the exception continues to propagate up the call stack.

A Classic Example: Resource Cleanup

The most common use case for a finally block is to ensure that unmanaged resources are properly disposed of. An unmanaged resource is something that the language's garbage collector doesn't know how to clean up, like a file handle, a database connection, or a network socket.

Here's a classic example of using finally to ensure a file is closed (in C#):

System.IO.StreamReader reader = null;
try
{
    reader = new System.IO.StreamReader("my_file.txt");
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
}
catch (System.IO.FileNotFoundException ex)
{
    Console.WriteLine("Error: The file was not found.");
}
finally
{
    // This code is guaranteed to run.
    if (reader != null)
    {
        // Ensure the file handle is released.
        reader.Close();
    }
}

Without the finally block, if an error occurred while reading the file, the reader.Close() call might never be reached, leaving the file handle open and locking the file.

A More Modern Approach: using and try-with-resources

This try-finally pattern for resource cleanup is so important and so common that most modern languages have introduced a simpler syntax to handle it automatically.

In C# (using statement):

try
{
    using (var reader = new System.IO.StreamReader("my_file.txt"))
    {
        string content = reader.ReadToEnd();
        Console.WriteLine(content);
    }
}
catch (System.IO.FileNotFoundException ex)
{
    Console.WriteLine("Error: The file was not found.");
}

The using statement is just syntactic sugar for a try-finally block. It automatically calls the Dispose() method (which closes the file) on the reader object when the block is exited, even if an exception occurs.

In Python (with statement):

try:
    with open('my_file.txt', 'r') as f:
        content = f.read()
        print(content)
except FileNotFoundError:
    print("Error: The file was not found.")

Similarly, the with statement in Python ensures that the file's __exit__ method is called, which closes the file.

Conclusion

The finally block is a fundamental construct for writing robust and reliable code. It provides an absolute guarantee that a block of code will be executed, which is essential for releasing critical resources and preventing leaks. While modern language features like C#'s using statement have made manual try-finally blocks less common for resource management, understanding how finally works is key to understanding the principles of structured exception handling and resource safety.