IDisposable and using Statement in C# — Why, When and How to Clean Up Properly

using System;
using System.IO;

class ResourceLeakDemo
{
    static void Main()
    {
        // ❌ BAD PATTERN — no disposal, resource leak guaranteed
        // The StreamReader holds an OS file handle open.
        // The GC will eventually collect it, but we have no idea when.
        // In a busy app, you can run out of file handles before GC kicks in.
        var leakyReader = new StreamReader("example.txt");
        string firstLine = leakyReader.ReadLine();
        Console.WriteLine($"Read (leaky way): {firstLine}");
        // File handle is still open here. If this method is called in a loop,
        // you'll hit 'Too many open files' IOException.

        // ✅ GOOD PATTERN — explicit Dispose call
        // Dispose() closes the OS file handle immediately, right here.
        var safeReader = new StreamReader("example.txt");
        try
        {
            string safeFirstLine = safeReader.ReadLine();
            Console.WriteLine($"Read (safe way): {safeFirstLine}");
        }
        finally
        {
            // finally block guarantees Dispose runs even if ReadLine() throws.
            safeReader.Dispose();
            Console.WriteLine("File handle released immediately.");
        }
    }
}

using System;
using System.IO;

class UsingStatementPatterns
{
    static void Main()
    {
        // ── Pattern 1: Classic using block ──────────────────────────────
        // The compiler wraps this in a hidden try/finally.
        // StreamReader.Dispose() is called the moment we exit the braces.
        using (var classicReader = new StreamReader("example.txt"))
        {
            string content = classicReader.ReadToEnd();
            Console.WriteLine($"Classic using: '{content.Trim()}'\n");
        } // <-- Dispose() called here, file handle released

        // ── Pattern 2: C# 8 using declaration (no curly braces) ─────────
        // The variable lives until the end of this method (Main).
        // Dispose() is called when Main() exits, or if an exception escapes.
        using var modernReader = new StreamReader("example.txt");
        string modernContent = modernReader.ReadToEnd();
        Console.WriteLine($"Modern using: '{modernContent.Trim()}'\n");
        // modernReader.Dispose() will be called automatically at end of Main()

        // ── Pattern 3: Stacking multiple using statements ────────────────
        // No pyramid nesting needed. Disposal order: writer first, then reader.
        // (Last declared = first disposed, just like a stack unwinding)
        using var inputReader  = new StreamReader("example.txt");
        using var outputWriter = new StreamWriter("output.txt");

        string line;
        while ((line = inputReader.ReadLine()) != null)
        {
            outputWriter.WriteLine(line.ToUpper());
        }

        Console.WriteLine("Stacked using: file copied and uppercased.");
        // outputWriter.Dispose() called first (flushes buffer to disk)
        // inputReader.Dispose() called second
        // Both file handles cleanly released
    }
}

using System;
using System.IO;

/// <summary>
/// A class that wraps a StreamWriter (an IDisposable) and exposes
/// a clean, disposable interface to callers.
/// This demonstrates the canonical IDisposable implementation pattern.
/// </summary>
public class ManagedFileProcessor : IDisposable
{
    private StreamWriter _writer;       // the inner IDisposable we're wrapping
    private bool _isDisposed = false;  // guards against double-disposal

    public ManagedFileProcessor(string filePath)
    {
        // We own this StreamWriter — we're responsible for disposing it.
        _writer = new StreamWriter(filePath, append: true);
        Console.WriteLine($"ManagedFileProcessor opened: {filePath}");
    }

    public void WriteEntry(string message)
    {
        // Always check before using — throw a helpful exception if disposed.
        // ObjectDisposedException is the standard .NET exception for this case.
        ThrowIfDisposed();

        string timestampedMessage = $"[{DateTime.Now:HH:mm:ss}] {message}";
        _writer.WriteLine(timestampedMessage);
        Console.WriteLine($"Written: {timestampedMessage}");
    }

    // ── Public Dispose: called explicitly by consumers ─────────────────────
    public void Dispose()
    {
        Dispose(disposing: true);

        // Tell the GC not to bother calling the finalizer (if we had one).
        // Since we've already cleaned up, running the finalizer would be wasted work.
        GC.SuppressFinalize(this);
    }

    // ── Protected Dispose(bool): the real cleanup logic ────────────────────
    // 'disposing = true'  → called from our public Dispose(), safe to touch managed objects
    // 'disposing = false' → called from GC finalizer, only touch unmanaged resources
    protected virtual void Dispose(bool disposing)
    {
        if (_isDisposed)
            return; // idempotent — safe to call Dispose() multiple times

        if (disposing)
        {
            // Dispose managed resources — the StreamWriter is managed (it wraps
            // an OS handle, but it knows how to clean that up via its own Dispose).
            _writer?.Dispose();
            Console.WriteLine("ManagedFileProcessor: StreamWriter disposed.");
        }

        // If we had raw unmanaged resources (IntPtr handles, etc.) we'd free them here,
        // regardless of the 'disposing' flag.

        _isDisposed = true;
    }

    private void ThrowIfDisposed()
    {
        if (_isDisposed)
            throw new ObjectDisposedException(
                nameof(ManagedFileProcessor),
                "Cannot write to a processor that has already been disposed.");
    }
}

class Program
{
    static void Main()
    {
        // using guarantees Dispose() even if WriteEntry() throws
        using (var processor = new ManagedFileProcessor("app.log"))
        {
            processor.WriteEntry("Application started.");
            processor.WriteEntry("Processing batch job #42.");
        } // Dispose() automatically called here

        Console.WriteLine("--- Processor is now disposed ---");

        // Demonstrate that double-Dispose is safe
        var processor2 = new ManagedFileProcessor("app.log");
        processor2.Dispose();
        processor2.Dispose(); // second call — should not throw or crash
        Console.WriteLine("Double-Dispose completed safely.");
    }
}

using System;
using System.Data;
using System.Data.SqlClient;

class DatabaseConnectionDemo
{
    // Connection string — in real apps this comes from configuration, not hardcoded.
    private const string ConnectionString =
        "Server=localhost;Database=ShopDb;Integrated Security=true;";

    // ❌ DANGEROUS: Connection is never returned to pool
    static void GetProductNameLeaky(int productId)
    {
        var connection = new SqlConnection(ConnectionString);
        connection.Open(); // borrows a slot from the pool

        var command = new SqlCommand(
            "SELECT ProductName FROM Products WHERE Id = @id", connection);
        command.Parameters.AddWithValue("@id", productId);

        string productName = (string)command.ExecuteScalar();
        Console.WriteLine($"[Leaky] Product: {productName}");

        // No Dispose() — connection stays borrowed from pool forever (until GC, eventually).
        // Under load, call this 100 times and the pool is exhausted.
    }

    // ✅ SAFE: using guarantees both connection and command are returned/released
    static string GetProductNameSafely(int productId)
    {
        // Nested using statements — SqlCommand is disposed before SqlConnection.
        // SqlConnection.Dispose() returns the connection to the pool immediately.
        using var connection = new SqlConnection(ConnectionString);
        connection.Open();

        using var command = new SqlCommand(
            "SELECT ProductName FROM Products WHERE Id = @id", connection);

        // Always use parameterized queries — prevents SQL injection
        command.Parameters.Add("@id", SqlDbType.Int).Value = productId;

        string productName = (string)command.ExecuteScalar();
        Console.WriteLine($"[Safe] Product: {productName}");

        return productName;
        // When this method exits: command.Dispose() first, then connection.Dispose()
        // Connection is immediately available in the pool for the next request.
    }

    // ✅ PATTERN: Wrapping in a service class — consumers don't touch SqlConnection directly
    static void Main()
    {
        // In unit tests or when DB isn't available, wrap in try/catch
        try
        {
            string name = GetProductNameSafely(productId: 1);
            Console.WriteLine($"Final result: {name}");
        }
        catch (SqlException ex)
        {
            Console.WriteLine($"DB error (expected in demo without real DB): {ex.Number}");
        }
    }
}