IDisposable & Finalizers

The Garbage Collector is amazing at cleaning up C# objects (Managed Memory), but it is completely blind to Unmanaged Resources like Database Connections, File Handles, and Network Sockets. If you don't manually release these, your server will eventually hit a "Socket Exhaustion" or "File Lock" error.

1. The IDisposable Interface

This is the standard C# mechanism for manual cleanup. When you implement IDisposable, you are providing a Dispose() method that the consumer can call to release resources immediately.

public class DatabaseService : IDisposable 
{
    private SqlConnection _connection;

    public void Dispose() 
    {
        // Close the expensive hardware connection immediately!
        _connection.Dispose(); 
    }
}

2. Using Declarations (C# 8+)

Instead of bulky using (var x = ...) { } blocks, modern C# allows you to just use the using keyword before a variable declaration. The object will be automatically disposed of the exact millisecond the thread leaves the current scope.

public void ProcessFile() 
{
    // Clean, concise, and safe.
    using var stream = File.OpenRead("data.bin");
    
    // Do work...
} // stream.Dispose() is automatically called HERO!

3. Finalizers (~Class)

A finalizer is a "Last Resort." If a developer forgets to call Dispose(), the Garbage Collector will eventually call the Finalizer before deleting the object. However, Finalizers are slow and unreliable. Always prefer IDisposable.

4. Interview Mastery

Q: "What is the 'Dispose Pattern' (the protected virtual Dispose(bool disposing) method) and why do we use it?"

Architect Answer: "The Dispose Pattern is a safety framework to ensure that resources are cleaned up correctly whether called manually or by the GC. `Dispose(true)` means we are cleaning up both managed and unmanaged resources. `Dispose(false)` (from the Finalizer) means we ONLY clean up unmanaged resources, because the managed objects might have already been deleted by the GC. This pattern prevents 'Double-Disposal' and ensures that even if a developer is lazy, your unmanaged memory won't leak forever."