C# 解構函式與 IDisposable 模式完整指南：資源管理最佳實踐

前言

在 .NET 托管環境中，記憶體由垃圾收集器 (GC) 自動管理，但非托管資源（檔案控制代碼、資料庫連線、網路 Socket、GDI 物件、COM 物件等）必須由開發者明確釋放。本文完整解析解構函式、IDisposable、Dispose Pattern、using 陳述式的關係與正確用法。

核心概念釐清

解構函式限制與行為

public class MyClass
{
    // 1. 無法指定存取修飾詞 (隱含 protected)
    // 2. 無參數、無法多載、無法繼承
    // 3. 無法直接呼叫
    ~MyClass()
    {
        // 編譯器轉換為：
        // protected override void Finalize()
        // {
        //     try { /* 釋放非托管資源 */ }
        //     finally { base.Finalize(); }
        // }
        
        // 僅釋放非托管資源！
        // 此時托管物件可能已被回收，不可觸碰
    }
}

關鍵警告

• 執行時間不確定：可能在程式結束很久後才執行
• 例外會被吞沒：Finalizer 執行緒上的未處理例外會終止進程 (.NET 2.0+)
• 效能影響：有 Finalize 的物件需經過兩輪 GC 才能回收 (Gen 0 → Finalizer Queue → Gen 1/2)
• 不保证順序：物件圖中 Finalize 順序不可預測

標準 Dispose Pattern 完整實作

using System;

public class ResourceHolder : IDisposable
{
    // 非托管資源 (IntPtr, SafeHandle, 檔案控制代碼等)
    private IntPtr _unmanagedHandle = IntPtr.Zero;
    
    // 托管資源 (實作 IDisposable 的物件)
    private FileStream _fileStream;
    private Timer _timer;
    
    // 狀態旗標
    private bool _disposed = false;
    
    public ResourceHolder(string filePath)
    {
        // 取得非托管資源
        _unmanagedHandle = NativeMethods.OpenFile(filePath);
        if (_unmanagedHandle == IntPtr.Zero)
            throw new System.ComponentModel.Win32Exception();
            
        // 取得托管資源
        _fileStream = new FileStream(filePath, FileMode.Open);
        _timer = new Timer(Callback, null, 1000, 1000);
    }
    
    // 公開 Dispose：開發者主動呼叫
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this); // 關鍵：告訴 GC 不需呼叫 Finalize
    }
    
    // 核心邏輯：disposing 區分呼叫來源
    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return; // 避免重複釋放
        
        if (disposing)
        {
            // === 釋放托管資源 (僅開發者呼叫時) ===
            _timer?.Dispose();
            _timer = null;
            
            _fileStream?.Dispose();
            _fileStream = null;
            
            // 其他 IDisposable 物件...
        }
        
        // === 釋放非托管資源 (兩種情況都要) ===
        if (_unmanagedHandle != IntPtr.Zero)
        {
            NativeMethods.CloseHandle(_unmanagedHandle);
            _unmanagedHandle = IntPtr.Zero;
        }
        
        _disposed = true;
    }
    
    // 解構函式：最後防線
    ~ResourceHolder()
    {
        // 僅釋放非托管資源
        Dispose(false);
    }
    
    // 使用範例方法
    public void ReadData()
    {
        if (_disposed) throw new ObjectDisposedException(nameof(ResourceHolder));
        // 讀取邏輯...
    }
    
    private void Callback(object state) { /* 定時工作 */ }
}

internal static class NativeMethods
{
    [System.Runtime.InteropServices.DllImport("kernel32.dll")]
    public static extern IntPtr OpenFile(string path);
    
    [System.Runtime.InteropServices.DllImport("kernel32.dll")]
    public static extern bool CloseHandle(IntPtr handle);
}

密封類別簡化版

public sealed class SimpleResource : IDisposable
{
    private bool _disposed;
    private IntPtr _handle;
    
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    
    // 密封類別無需 virtual、無需 protected
    private void Dispose(bool disposing)
    {
        if (_disposed) return;
        
        if (disposing)
        {
            // 釋放托管資源
        }
        
        // 釋放非托管資源
        if (_handle != IntPtr.Zero)
        {
            NativeMethods.CloseHandle(_handle);
            _handle = IntPtr.Zero;
        }
        
        _disposed = true;
    }
    
    ~SimpleResource() => Dispose(false);
}

SafeHandle：現代非托管資源包裝器

強烈建議：不用手寫 IntPtr + Finalize，改用 SafeHandle 衍生類別，由 Runtime 保證釋放：

using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;

public class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid
{
    public SafeFileHandle(IntPtr handle, bool ownsHandle) : base(ownsHandle)
    {
        SetHandle(handle);
    }
    
    protected override bool ReleaseHandle()
    {
        return NativeMethods.CloseHandle(handle);
    }
}

// 使用
public class ModernResource : IDisposable
{
    private SafeFileHandle _handle;
    private FileStream _stream;
    
    public void Dispose()
    {
        _handle?.Dispose(); // SafeHandle 內建 Finalize 保護
        _stream?.Dispose();
    }
}

using 陳述式與 C# 8 using 宣告

傳統 using 區塊

using (var resource = new ResourceHolder("data.txt"))
{
    resource.ReadData();
} // 編譯器產生 try/finally 確保 Dispose()

C# 8+ using 宣告 (隱含區塊)

public void Process()
{
    using var resource = new ResourceHolder("data.txt"); // 方法結束時自動 Dispose
    using var stream = File.OpenRead("data.txt");
    
    resource.ReadData();
    // 即使拋出例外，兩者都會被 Dispose
}

編譯器產生的等價代碼

ResourceHolder resource = new ResourceHolder("data.txt");
try
{
    resource.ReadData();
}
finally
{
    if (resource != null)
        ((IDisposable)resource).Dispose();
}

常見錯誤與反模式

進階主題

1. 非同步釋放

public interface IAsyncDisposable
{
    ValueTask DisposeAsync();
}

public class AsyncResource : IAsyncDisposable
{
    private HttpClient _client = new HttpClient();
    
    public async ValueTask DisposeAsync()
    {
        await _client.DisposeAsync(); // 非同步釋放
    }
}

// 使用
await using var resource = new AsyncResource();

2. 容器/依賴注入中的生命週期管理

// ASP.NET Core / .NET Generic Host
services.AddScoped(); // Request 結束自動 Dispose
services.AddSingleton(); // 應用程式結束 Dispose
services.AddTransient(); // 每次建立，需手動管理

// 實作 IAsyncDisposable 的服務會在對應時機自動 DisposeAsync

3. 記憶體壓力與大型物件堆積 (LOH)

// 大型陣列 (>85KB) 進入 LOH，GC 成本高
// 使用 ArrayPool 避免頻繁配置
byte[] buffer = ArrayPool.Shared.Rent(100000);
try { /* 使用 buffer */ }
finally { ArrayPool.Shared.Return(buffer); }

總結

資源管理鐵律：誰配置，誰負責釋放。標準流程：

1. 類別持有非托管資源 → 實作 IDisposable + 完整 Dispose Pattern
2. 優先使用 SafeHandle 衍生類別包裝非托管控制代碼
3. 消費端 永遠使用 using (區塊或宣告) 確保釋放
4. Finalize 只作為最後安全網，不應依賴它 釋放關鍵資源
5. 現代 .NET：IAsyncDisposable、ArrayPool、DI 容器生命週期管理

記住：GC.Collect() 不是解決資源洩漏的辦法，正確的 Dispose 模式才是。