Using vs. Try-Finally

Both using statements and try-finally blocks help manage resources that need to be properly disposed of. The using statement provides a cleaner, more concise way to ensure that IDisposable objects are properly cleaned up.

Let's look at a try-finally approach first. Here, StreamReader is a class that reads text from a file — it holds an open file handle, which is a resource that must be released when we're done:

StreamReader reader = null;
try
{
    reader = new StreamReader("file.txt");
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
}
finally
{
    if (reader != null)
    {
        reader.Dispose();
    }
}

The finally block guarantees that Dispose() is called to release the file handle, even if an exception occurs inside the try block.

The using statement simplifies this pattern. It declares and initializes the resource in parentheses, and automatically calls Dispose() when the block exits — whether normally or due to an exception:

using (StreamReader reader = new StreamReader("file.txt"))
{
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
}

This is equivalent to the try-finally example above, but with less boilerplate code.

The using statement automatically calls Dispose() when the block exits, even if an exception occurs. It replaces the try-finally cleanup pattern — not try-catch. If you also need to handle exceptions, you can still wrap a using block inside a try-catch.