一、IDisposable：顯式釋放資源的契約

1. 為什么要使用IDisposable

先看一個問題：C# 會自動清理垃圾，為什么還需要手動釋放？
C# 的內存（比如你 new 出來的對象）確實由垃圾回收器（GC）自動管理，你不用管。但是程序里還有一些不屬于內存的東西，比如：

• 文件（你打開了一個文件，就占用了操作系統(tǒng)的文件句柄）
• 數(shù)據(jù)庫連接（你連上了數(shù)據(jù)庫，數(shù)據(jù)庫服務器那邊有資源）
• 網(wǎng)絡端口（你發(fā) HTTP 請求，系統(tǒng)開了端口）
• 繪圖畫筆（你畫圖時用的 GDI 對象）

這些東西，GC 不認識，也不會幫你去關。如果你不主動釋放，它們會一直存在，導致：

• 文件被你的程序一直占著，別人打不開
• 數(shù)據(jù)庫連接數(shù)爆滿，新用戶連不上
• 程序越跑越慢，最后崩潰

所以，C# 給了你一個約定：如果你用了這種特殊資源，你用完必須親自歸還。
這個約定就是 IDisposable。

2. IDisposable 就像一張“歸還資源的標簽”

C# 源碼里面的IDisposable 是一個接口，里面只有一句話：

void Dispose();

任何類（比如 FileStream、SqlConnection）只要實現(xiàn)了這個接口，就等于貼了個標簽：“我占用了特殊資源，用完請調用我的 Dispose() 方法歸還”。

FileStream fs = new FileStream("a.txt", FileMode.Open);
// ... 使用文件
fs.Dispose();   // 歸還文件

但是這樣寫有個隱患：如果中間代碼拋出異常，Dispose() 可能永遠不會執(zhí)行，資源照樣泄露。你還得寫 try-finally：

FileStream fs = null;
try{
    fs = new FileStream("a.txt", FileMode.Open);// 使用文件
}finally{
    if (fs != null) fs.Dispose();
}

太麻煩，而且容易忘。于是 C# 提供了一個語法糖using 。

3. 什么時候自己實現(xiàn) IDisposable

如果你的類里面包含了需要釋放的東西，那么你的類也應該實現(xiàn) IDisposable。

class Logger : IDisposable{
    private FileStream logFile;  // 這個需要釋放！
    public Logger(string path){
        logFile = new FileStream(path, FileMode.Append);
    }
    public void Write(string msg) {
        // 寫日志
    }
    public void Dispose(){
        logFile?.Dispose();   // 釋放掉內部的資源
    }
}

然后別人用你的 Logger 時：

using (var logger = new Logger("app.log")){
    logger.Write("程序啟動");
}
// 自動釋放文件

原則： 如果你的類里有任何 IDisposable 類型的成員（比如 FileStream、SqlConnection），你就應該實現(xiàn) IDisposable，并在 Dispose() 里調用它們的 Dispose()。

二、using 語句：優(yōu)雅且安全的自動釋放

1. using 就是幫你自動寫 try-finally 的偷懶工具

using 語句的作用： 出了這個大括號，自動調用 Dispose()，不管有沒有異常。

基本用法：

using (FileStream fs = new FileStream("a.txt", FileMode.Open)){
    // 使用 fs 讀文件
}
// 到這里，自動 fs.Dispose()

-----------------------------------------
//而上面的using基本用法和下面這段代碼實現(xiàn)是一樣的
FileStream fs = new FileStream("a.txt", FileMode.Open);
try{
    // 使用 fs
}finally{
    if (fs != null) fs.Dispose();
}

所以 using 的本質 = 自動 + 安全的資源歸還

2. 如果用 using 包多個資源

等價于嵌套的 try-finally，保證兩個都被釋放。

using (FileStream input = File.OpenRead("1.txt"))
using (FileStream output = File.OpenWrite("2.txt"))
{
    // 復制文件內容
}
// 先自動釋放 output，再釋放 input

3. C# 8 之后更簡單的寫法：using 聲明

using var fs = new FileStream("a.txt", FileMode.Open);
// 使用 fs
// 方法結束時會自動 Dispose()

效果： fs 的生命周期持續(xù)到方法結束，而不是大括號結束。適合那些“在整個方法里都要用，最后一起釋放”的場景。

void ReadFile(){
    using var fs = new FileStream("a.txt", FileMode.Open);
    // 在這里使用 fs
    // 方法是這里結束，fs 自動釋放
}

4. 延遲釋放與手動控制生命周期

有些場景你不想在代碼塊結束立刻釋放，比如把對象返回給調用方使用。這時就不能在方法內 using。而在創(chuàng)建資源的責任交給調用方，調用方負責 using。

// 不負責釋放
public Stream GetStream(){
    return new FileStream("data.bin", FileMode.Open);
}
// 調用方：
using (var stream = GetStream()){
    // 調用方負責釋放
}

四、Dispose 模式

如果你寫一個類，內部只包含托管資源（例如另一個 IDisposable 對象），只需要：

public class MyClass : IDisposable{
    private SqlConnection conn;
    public void Dispose() => conn?.Dispose();
}

這完全正確，對于大多數(shù)日常業(yè)務代碼已經足夠。但是，當你面對以下情況時，簡單的 Dispose 就不夠了：

1. 類直接持有非托管資源（比如通過 IntPtr 獲得的文件句柄、GDI 對象、原生內存）
2. 類可能被繼承，派生類也可能有自己的資源需要釋放
3. 用戶可能忘記調用 Dispose，導致非托管資源泄漏
   為了同時解決這三個問題，.NET 設計了一個經典的 Dispose 模式（也叫“可釋放模式”），它包含：

• Dispose() 公共方法
• protected virtual void Dispose(bool disposing) 方法
• 終結器（析構函數(shù)）
• GC.SuppressFinalize(this)

Dispose 模式 其實在實際開發(fā)并不常見，這里詳情就懶得寫了
Dispose 模式 = 一個 Dispose() 方法 + 一個受保護的 Dispose(bool) 虛方法 + 一個終結器（僅當有非托管資源時）。

到此這篇關于C# IDisposable 和 using的使用小結的文章就介紹到這了,更多相關C# IDisposable 和 using內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論