Finally Blocks - Cleaning Up After Exceptions

Vaibhav • September 10, 2025

In the previous articles, you learned how exceptions work and how to catch them using try and catch blocks. You saw how to handle specific exception types, inspect exception objects, and throw your own when needed. But there’s one more piece to structured exception handling that’s often overlooked-and it’s just as important: the finally block.

The finally block is designed for cleanup. It runs after the try and catch blocks, no matter what happens. Whether an exception is thrown, caught, or not thrown at all, the finally block always executes. This makes it the perfect place to release resources, reset state, or perform any final steps that must happen regardless of success or failure.

Why Finally Exists

Imagine you open a file, connect to a database, or start a timer. If something goes wrong halfway through, you don’t want to leave those resources hanging. Even if everything goes right, you still need to clean up. That’s what finally is for-it guarantees that cleanup code runs no matter what.

try
{
    Console.WriteLine("Opening resource...");
    // Simulate risky operation
    throw new InvalidOperationException("Something went wrong.");
}
catch (Exception ex)
{
    Console.WriteLine("Caught: " + ex.Message);
}
finally
{
    Console.WriteLine("Cleaning up.");
}

In this example, the exception is caught, and the finally block still runs. Even if no exception were thrown, finally would still execute. That’s its defining feature.

Finally Without Catch

You can use finally even if you don’t include a catch block. This is useful when you want to clean up but let the exception propagate to a higher level.

try
{
    Console.WriteLine("Doing something risky...");
    throw new Exception("Boom!");
}
finally
{
    Console.WriteLine("Always runs.");
}

In this case, the exception is not caught locally, but finally still runs before the exception bubbles up. This pattern is common in library code where you want to ensure cleanup but let the caller handle the error.

Finally With Return Statements

Even if the try or catch block contains a return statement, the finally block still runs. This can surprise beginners, but it’s consistent with the idea that finally always executes.

int Compute()
{
    try
    {
        return 42;
    }
    finally
    {
        Console.WriteLine("Cleaning up before returning.");
    }
}

When you call Compute(), it returns 42, but not before printing the cleanup message. This behavior ensures that cleanup happens even when control flow exits early.

Finally With Nested Try-Catch

You can nest try/catch/finally blocks, and each finally will run in its own scope. This is useful when you have multiple layers of operations that each need their own cleanup.

try
{
    Console.WriteLine("Outer try");
    try
    {
        Console.WriteLine("Inner try");
        throw new Exception("Inner error");
    }
    catch
    {
        Console.WriteLine("Inner catch");
    }
    finally
    {
        Console.WriteLine("Inner finally");
    }
}
finally
{
    Console.WriteLine("Outer finally");
}

This example shows how both finally blocks run, even though the exception is caught in the inner block. Each finally is tied to its own try.

Finally With Resource Management

One of the most common uses of finally is to release resources like file handles, network connections, or timers. Even though .NET provides automatic memory management, some resources still need manual cleanup.

StreamReader reader = null;
try
{
    reader = new StreamReader("data.txt");
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
}
catch (IOException ex)
{
    Console.WriteLine("File error: " + ex.Message);
}
finally
{
    if (reader != null)
        reader.Close();
}

This pattern ensures that the file is closed whether reading succeeds or fails. Without finally, you risk leaving the file open if an exception occurs.

Finally vs Using Statement

In later chapters, you’ll learn about the using statement, which simplifies resource cleanup for types that implement IDisposable. Under the hood, using is just syntactic sugar for a try/finally block.

// Equivalent to try-finally
using (StreamReader reader = new StreamReader("data.txt"))
{
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
}

This pattern is cleaner and less error-prone, but it only works with disposable types. For other cleanup tasks, finally remains essential.

Exceptions Inside Finally

If an exception is thrown inside a finally block, it can override any previous exception. This is dangerous because it can hide the original error and make debugging harder.

try
{
    throw new Exception("Original error");
}
finally
{
    throw new Exception("Cleanup error");
}

In this case, the second exception replaces the first. The original error is lost. This is why you should avoid throwing exceptions from finally unless absolutely necessary.

When Not to Use Finally

If your code doesn’t need cleanup, you can skip finally. But be cautious-many operations seem safe until they fail unexpectedly. It’s better to include a finally block and keep it empty than to forget cleanup entirely.

Also, avoid using finally for control flow or business logic. It’s meant for cleanup, not decision-making. Keep it focused and predictable.

Summary

In this article, you learned how the finally block fits into C# exception handling. You saw how it guarantees cleanup regardless of success or failure, how it interacts with return statements and nested blocks, and how to use it for resource management. You also learned about the risks of throwing exceptions from finally and how it compares to the using statement.

The finally block is your safety net. It ensures that your program leaves things in a clean state, even when things go wrong. In the next article, we’ll explore Exception Types: the built-in exceptions C# provides, when they occur, and how to choose the right one when throwing your own.