Improper disposals

using System;

// A class that owns an unmanaged resource, implementing IDisposable.
public class FileLogger : IDisposable
{
    private System.IO.StreamWriter _fileStream;

    // A flag to track if the object has already been disposed.
    private bool _disposed = false;

    public FileLogger(string filePath)
    {
        // Acquire the unmanaged resource (a file handle).
        _fileStream = new System.IO.StreamWriter(filePath);
    }

    public void Log(string message)
    {
        if (_disposed)
            throw new ObjectDisposedException("FileLogger");

        _fileStream.WriteLine(message);
    }

    // The public Dispose method, called by the consumer.
    public void Dispose()
    {
        Dispose(true);
        // Suppress finalization because the resource was already cleaned up.
        GC.SuppressFinalize(this);
    }

    // The core disposal logic, reusable by the finalizer.
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // Release other managed objects (if any).
                // _fileStream is a managed object that ALSO implements IDisposable.
                _fileStream?.Dispose();
            }

            // Release unmanaged resources directly (e.g., Win32 handles) here.
            // In this case, _fileStream.Dispose() handles the unmanaged file handle.
            _disposed = true;
        }
    }

    // Finalizer (destructor) - a safety net if Dispose is not called.
    ~FileLogger()
    {
        Dispose(false);
    }
}

// The 'using' statement ensures _logger.Dispose() is called upon exiting the block.
using (var _logger = new FileLogger("log.txt"))
{
    _logger.Log("This message is written to the file.");
    // Even if an exception is thrown here, Dispose() will be called.
} // _logger.Dispose() is automatically called here.

// Modern C# (version 8.0+) also supports a using declaration, which disposes at the end of the scope.
using var _logger = new FileLogger("log.txt");
_logger.Log("This message is written to the file.");
} // _logger is disposed here when it goes out of scope.

// As shown in the FileLogger example above:
~FileLogger()
{
    // When called by the GC, 'disposing' is false. We only clean up unmanaged resources.
    // We cannot touch managed objects (like _fileStream) as they may have been finalized already.
    Dispose(false);
}

using System;
using Microsoft.Win32.SafeHandles;

public class UnmanagedResourceWrapper : IDisposable
{
    // Using SafeHandle to wrap the unmanaged resource.
    private SafeFileHandle _safeHandle;

    public UnmanagedResourceWrapper(string fileName)
    {
        // P/Invoke call to open a file. Assume it returns an IntPtr.
        IntPtr fileHandle = NativeMethods.OpenFile(fileName);

        // Wrap the raw handle in a SafeHandle. This is now a managed object.
        _safeHandle = new SafeFileHandle(fileHandle, true);
    }

    public void UseResource()
    {
        // Use the SafeHandle to perform operations.
        if (_safeHandle.IsInvalid)
            throw new InvalidOperationException("Handle is invalid.");

        // ... work with the handle via _safeHandle.DangerousGetHandle() if necessary.
    }

    // Dispose implementation becomes trivial. SafeHandle owns the disposal logic.
    public void Dispose()
    {
        _safeHandle?.Dispose();
    }

    // NO NEED TO WRITE A FINALIZER. SafeHandle has its own, which will ensure the resource is closed.
}

internal static class NativeMethods
{
    // Simulated P/Invoke signature.
    [System.Runtime.InteropServices.DllImport("kernel32.dll")]
    internal static extern IntPtr OpenFile(string fileName);
}