IDisposable — Missing Dispose Exhausts Connection Pools

using System;
using System.IO;

namespace TheCodeForge.Demos
{
    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;

namespace TheCodeForge.Demos
{
    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;

namespace TheCodeForge.Demos
{
    /// <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;

namespace TheCodeForge.Demos
{
    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}");
            }
        }
    }
}

using System;
using System.IO;
using System.Threading.Tasks;

namespace TheCodeForge.AsyncPatterns
{
    public class AsyncResourceHolder : IAsyncDisposable
    {
        private FileStream _fileStream;
        private bool _disposed = false;

        public AsyncResourceHolder(string path)
        {
            _fileStream = new FileStream(path, FileMode.Create);
        }

        public async Task WriteAsync(string content)
        {
            ThrowIfDisposed();
            byte[] buffer = System.Text.Encoding.UTF8.GetBytes(content);
            await _fileStream.WriteAsync(buffer, 0, buffer.Length);
        }

        // ── Public DisposeAsync ─────────────────────────────────────────
        public async ValueTask DisposeAsync()
        {
            await DisposeAsyncCore();

            Dispose(disposing: false);
            GC.SuppressFinalize(this);
        }

        // ── Protected virtual DisposeAsyncCore ──────────────────────────
        // Only dispose managed resources here.
        // Subclasses can override this to add their own async cleanup.
        protected virtual async ValueTask DisposeAsyncCore()
        {
            if (_disposed)
                return;

            if (_fileStream != null)
            {
                // Flush and close async
                await _fileStream.FlushAsync();
                await _fileStream.DisposeAsync();
                _fileStream = null;
            }

            _disposed = true;
        }

        // ── Synchronous Dispose for fallback (if needed) ────────────────
        // Usually not needed if you implement only IAsyncDisposable.
        // But if you also implement IDisposable, call DisposeAsyncCore synchronously?
        // Better to throw NotSupportedException and tell callers to use await using.
        public void Dispose()
        {
            throw new NotSupportedException(
                "Use await using to dispose this resource asynchronously.");
        }

        private void ThrowIfDisposed()
        {
            if (_disposed)
                throw new ObjectDisposedException(nameof(AsyncResourceHolder));
        }
    }

    class AsyncDemo
    {
        static async Task Main()
        {
            await using var holder = new AsyncResourceHolder("log.txt");
            await holder.WriteAsync("Hello from async cleanup!");
            // holder.DisposeAsync() is called at end of scope
        }
    }
}

// io.thecodeforge — csharp tutorial

SqlConnection? conn = null;
try
{
    conn = new SqlConnection(connectionString);
    conn.Open();
    var cmd = new SqlCommand("SELECT * FROM Orders", conn);
    // ... execute and process
}
finally
{
    if (conn is not null)
    {
        conn.Dispose();
    }
}

// io.thecodeforge — csharp tutorial

public class DatabaseManager : IDisposable
{
    private SqlConnection? _connection;
    private bool _disposed;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;

        if (disposing)
        {
            _connection?.Dispose();
        }

        // TODO: free unmanaged resources here

        _disposed = true;
    }

    ~DatabaseManager()
    {
        Dispose(false);
    }
}

// io.thecodeforge — csharp tutorial
global using System;          // Every file in project
using System.Data;             // Only in this file

public class DatabaseReader {
    public DataTable Read() {
        var conn = new SqlConnection();  // From global System.Data
        Console.WriteLine("Connecting...");  // From global System
        return new DataTable();
    }
}

// io.thecodeforge — csharp tutorial
using WinForm = System.Windows.Forms;
using WebForm = System.Web.UI.WebControls;
using Project = MyCompany.Project;

public class FormHandler {
    public void Render() {
        var winBox = new WinForm::TextBox();  // Qualified alias
        var webBox = new WebForm::TextBox();  // Qualified alias
        var local = new Project::Foo();       // No collision
    }
}