资源管理与 IDisposable

简介

.NET 的垃圾回收器管理内存，但非内存资源（文件句柄、数据库连接、网络 Socket）需要手动释放。理解 IDisposable、using 语句和 IAsyncDisposable，有助于避免资源泄漏。

资源管理是 .NET 编程中最容易被忽视的领域之一。内存由 GC 自动管理，但文件句柄、数据库连接、网络 Socket、GDI 对象等非托管资源必须显式释放。如果忘记释放，会导致资源泄漏，最终可能耗尽系统资源，导致应用崩溃或无法打开新文件/连接。

特点

• 1.IDisposable — 标准资源释放模式
• 2.using 语句 — 自动调用 Dispose
• 3.终结器 — GC 兜底释放
• 4.IAsyncDisposable — 异步资源释放
• 5.SafeHandle — 安全的句柄包装
• 6.对象池 — 复用昂贵资源减少分配

资源分类

托管资源 vs 非托管资源

// ==========================================
// 托管资源（GC 自动管理）
// ==========================================
// - 普通对象（string, List<T>, 自定义类等）
// - 实现 IDisposable 的托管对象（由其自身管理释放）
// GC 会在不再引用时自动回收

// ==========================================
// 非托管资源（必须手动释放）
// ==========================================
// - 文件句柄（FileStream, StreamWriter）
// - 数据库连接（SqlConnection, NpgsqlConnection）
// - 网络套接字（Socket, TcpClient）
// - GDI+ 对象（Brush, Pen, Font — WinForms/WPF）
// - 窗口句柄（HWND）
// - 互斥体/信号量（Mutex, Semaphore）
// - COM 对象
// - 内存映射文件
// - 定时器（Timer）
// - 注册事件导致的引用

// 判断一个类是否需要实现 IDisposable：
// 1. 它是否直接持有非托管资源？
// 2. 它是否持有一个实现了 IDisposable 的托管对象？
// 如果任一答案是"是"，就应该实现 IDisposable

实现

标准 Dispose 模式

public class DatabaseConnection : IDisposable, IAsyncDisposable
{
    private SqlConnection? _connection;
    private SqlCommand? _command;
    private bool _disposed;

    public DatabaseConnection(string connectionString)
    {
        _connection = new SqlConnection(connectionString);
    }

    public async Task OpenAsync()
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
        await _connection!.OpenAsync();
    }

    // 同步释放
    public void Dispose()
    {
        if (_disposed) return;
        _command?.Dispose();
        _connection?.Dispose();
        _disposed = true;
        GC.SuppressFinalize(this); // 不需要终结器回收
    }

    // 异步释放
    public async ValueTask DisposeAsync()
    {
        if (_disposed) return;
        if (_command != null) await _command.DisposeAsync();
        if (_connection != null) await _connection.DisposeAsync();
        _disposed = true;
        GC.SuppressFinalize(this);
    }

    // 终结器 — GC 兜底（不推荐，仅用于未托管资源）
    ~DatabaseConnection() => Dispose();
}

// using 声明（C# 8+）
await using var conn = new DatabaseConnection("Server=...");
await conn.OpenAsync();
// 退出作用域自动 DisposeAsync

// 经典 using 语句
using (var stream = File.OpenRead("data.bin"))
{
    // 使用 stream
} // 自动 Dispose

完整 Dispose 模式（含终结器和线程安全）

/// <summary>
/// 完整的标准 Dispose 模式 — 适用于持有非托管资源的类
/// 参考: Microsoft 设计指南
/// </summary>
public class ResourceHolder : IDisposable, IAsyncDisposable
{
    // 非托管资源
    private IntPtr _nativeHandle;

    // 托管资源
    private FileStream? _fileStream;
    private Timer? _timer;

    // 释放标志
    private volatile bool _disposed;

    public ResourceHolder(string filePath)
    {
        // 分配非托管资源
        _nativeHandle = AllocateNativeResource();
        _fileStream = new FileStream(filePath, FileMode.Open);
        _timer = new Timer(OnTimer, null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));
    }

    private IntPtr AllocateNativeResource()
    {
        // 模拟非托管资源分配
        return Marshal.AllocHGlobal(1024);
    }

    private void OnTimer(object? state)
    {
        if (_disposed) return;
        // 定时器回调逻辑
    }

    // ==========================================
    // 公共 Dispose 方法
    // ==========================================
    public void Dispose()
    {
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    }

    // ==========================================
    // 公共 DisposeAsync 方法
    // ==========================================
    public async ValueTask DisposeAsync()
    {
        await DisposeAsyncCore().ConfigureAwait(false);
        Dispose(disposing: false);
        GC.SuppressFinalize(this);
    }

    // ==========================================
    // 受保护的虚拟 Dispose 方法（供子类重写）
    // ==========================================
    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;

        if (disposing)
        {
            // 释放托管资源
            // 注意：此处可以安全访问其他托管对象
            _timer?.Dispose();
            _timer = null;
            _fileStream?.Dispose();
            _fileStream = null;
        }

        // 释放非托管资源
        // 注意：此处不能访问托管对象，它们可能已被 GC 回收
        if (_nativeHandle != IntPtr.Zero)
        {
            Marshal.FreeHGlobal(_nativeHandle);
            _nativeHandle = IntPtr.Zero;
        }

        _disposed = true;
    }

    // ==========================================
    // 异步 Dispose 核心（释放需要异步等待的资源）
    // ==========================================
    protected virtual async ValueTask DisposeAsyncCore()
    {
        if (_fileStream != null)
        {
            await _fileStream.DisposeAsync().ConfigureAwait(false);
            _fileStream = null;
        }

        if (_timer != null)
        {
            await _timer.DisposeAsync().ConfigureAwait(false);
            _timer = null;
        }
    }

    // ==========================================
    // 终结器 — 仅释放非托管资源
    // ==========================================
    ~ResourceHolder()
    {
        Dispose(disposing: false);
    }

    // ==========================================
    // 公共方法中检查是否已释放
    // ==========================================
    private void ThrowIfDisposed()
    {
        ObjectDisposedException.ThrowIf(_disposed, this);
    }

    public void DoWork()
    {
        ThrowIfDisposed();
        // 业务逻辑...
    }
}

SafeHandle 包装非托管资源

// ==========================================
// SafeHandle — .NET 推荐的非托管资源包装方式
// ==========================================
// SafeHandle 提供了临界终止（Critical Finalization）保证
// 即使在终结器线程出现异常，资源也会被释放

public sealed class NativeResourceHandle : SafeHandleZeroOrMinusOneIsInvalid
{
    public NativeResourceHandle() : base(ownsHandle: true) { }

    protected override bool ReleaseHandle()
    {
        // 释放非托管资源
        // 此方法在终结器线程上调用，必须可靠
        return NativeMethods.CloseHandle(handle);
    }
}

public static class NativeMethods
{
    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool CloseHandle(IntPtr hObject);
}

// 使用 SafeHandle
public class SafeResourceHolder : IDisposable
{
    private readonly NativeResourceHandle _handle;

    public SafeResourceHolder()
    {
        _handle = new NativeResourceHandle();
        // 分配非托管资源
        _handle.SetHandle(NativeMethods.CreateResource());
    }

    public void Dispose()
    {
        _handle.Dispose();
    }

    // 不需要终结器！SafeHandle 自带
}

// ==========================================
// 常用的内置 SafeHandle
// ==========================================
// SafeFileHandle       — 文件句柄
// SafeWaitHandle       — 等待句柄（Mutex, Semaphore 等）
// SafePipeHandle       — 管道句柄
// SafeMemoryMappedViewHandle — 内存映射视图
// Microsoft.Win32.SafeHandles 命名空间下还有很多

自定义资源管理器

// 临时文件管理器
public sealed class TempFile : IDisposable
{
    public string Path { get; }
    public FileStream Stream { get; }

    public TempFile(string extension = ".tmp")
    {
        Path = System.IO.Path.Combine(System.IO.Path.GetTempPath(), Guid.NewGuid() + extension);
        Stream = File.Create(Path);
    }

    public void Dispose()
    {
        Stream.Dispose();
        try { File.Delete(Path); } catch { }
    }
}

// 使用
using var temp = new TempFile(".csv");
await temp.Stream.WriteAsync(Encoding.UTF8.GetBytes("hello"));
// 退出 using 自动删除临时文件

// ==========================================
// 资源作用域管理
// ==========================================
public class ResourceScope : IDisposable
{
    private readonly List<IDisposable> _resources = new();

    public T Add<T>(T resource) where T : IDisposable { _resources.Add(resource); return resource; }

    public void Dispose()
    {
        for (int i = _resources.Count - 1; i >= 0; i--)
            _resources[i].Dispose();
    }
}

using var scope = new ResourceScope();
var conn = scope.Add(new SqlConnection(connStr));
var cmd = scope.Add(new SqlCommand());
var reader = scope.Add(await cmd.ExecuteReaderAsync());
// 全部自动释放

// ==========================================
// 更好的资源作用域 — 异步支持
// ==========================================
public sealed class AsyncResourceScope : IAsyncDisposable
{
    private readonly List<IAsyncDisposable> _asyncResources = new();
    private readonly List<IDisposable> _syncResources = new();

    public T Add<T>(T resource) where T : IAsyncDisposable, IDisposable
    {
        _asyncResources.Add(resource);
        return resource;
    }

    public T Add<T>(T resource) where T : IDisposable
    {
        _syncResources.Add(resource);
        return resource;
    }

    public async ValueTask DisposeAsync()
    {
        var exceptions = new List<Exception>();

        // 先释放异步资源
        for (int i = _asyncResources.Count - 1; i >= 0; i--)
        {
            try { await _asyncResources[i].DisposeAsync(); }
            catch (Exception ex) { exceptions.Add(ex); }
        }

        // 再释放同步资源
        for (int i = _syncResources.Count - 1; i >= 0; i--)
        {
            try { _syncResources[i].Dispose(); }
            catch (Exception ex) { exceptions.Add(ex); }
        }

        if (exceptions.Count > 0)
            throw new AggregateException("释放资源时发生错误", exceptions);
    }
}

对象池

// ObjectPool<T> — 复用昂贵对象
public class ObjectPool<T> where T : class, new()
{
    private readonly ConcurrentBag<T> _pool = new();
    private readonly int _maxSize;
    private int _count;

    public ObjectPool(int maxSize = 100) => _maxSize = maxSize;

    public T Rent()
    {
        if (_pool.TryTake(out var item)) return item;
        Interlocked.Increment(ref _count);
        return new T();
    }

    public void Return(T item)
    {
        if (_count <= _maxSize)
            _pool.Add(item);
        else if (item is IDisposable disposable)
            disposable.Dispose();
    }
}

// pooled object pattern
public class PooledBuffer
{
    public byte[] Data { get; } = new byte[8192];
    public int Length { get; set; }

    public void Reset() => Length = 0;
}

// 使用
var pool = new ObjectPool<PooledBuffer>();
var buffer = pool.Rent();
try { /* 使用 buffer */ }
finally { buffer.Reset(); pool.Return(buffer); }

// .NET 内置 ObjectPool
var defaultPool = new DefaultObjectPool<PooledBuffer>(new DefaultPooledObjectPolicy<PooledBuffer>());
var obj = defaultPool.Get();
defaultPool.Return(obj);

// ==========================================
// 自定义池化策略
// ==========================================
public class BufferPoolPolicy : IPooledObjectPolicy<PooledBuffer>
{
    public PooledBuffer Create()
    {
        return new PooledBuffer(); // 创建新实例
    }

    public bool Return(PooledBuffer obj)
    {
        obj.Reset();
        return obj.Data.Length <= 1024 * 1024; // 超过 1MB 不回收
    }
}

// ArrayPool<T> — .NET 内置数组池
var arrayPool = ArrayPool<byte>.Shared;
var buffer = arrayPool.Rent(8192); // 可能返回更大的数组
try
{
    // 使用 buffer[0..8191]
    Console.WriteLine($"实际长度: {buffer.Length}"); // 可能 > 8192
}
finally
{
    arrayPool.Return(buffer, clearArray: true); // 清除数据后归还
}

常见资源泄漏场景

事件订阅泄漏

// ==========================================
// 事件订阅 — 最常见的"隐藏"资源泄漏
// ==========================================
public class EventBus
{
    public event Action<string>? MessageReceived;
    public void SendMessage(string msg) => MessageReceived?.Invoke(msg);
}

public class Subscriber : IDisposable
{
    private readonly EventBus _bus;

    public Subscriber(EventBus bus)
    {
        _bus = bus;
        _bus.MessageReceived += OnMessage; // 订阅事件
    }

    private void OnMessage(string msg) => Console.WriteLine(msg);

    public void Dispose()
    {
        _bus.MessageReceived -= OnMessage; // 必须取消订阅！
    }
}

// 如果不取消订阅，EventBus 会持有 Subscriber 的引用
// Subscriber 就无法被 GC 回收 → 内存泄漏

// ==========================================
// 弱引用事件模式 — 避免忘记取消订阅
// ==========================================
public class WeakEvent<TEventArgs> where TEventArgs : EventArgs
{
    private readonly List<WeakReference<EventHandler<TEventArgs>>> _handlers = new();

    public void Subscribe(EventHandler<TEventArgs> handler)
    {
        _handlers.Add(new WeakReference<EventHandler<TEventArgs>>(handler));
    }

    public void Raise(object sender, TEventArgs e)
    {
        // 清理已死亡的引用
        _handlers.RemoveAll(wr => !wr.TryGetTarget(out _));

        foreach (var wr in _handlers)
        {
            if (wr.TryGetTarget(out var handler))
                handler(sender, e);
        }
    }
}

Dispose 中的异常处理

// ==========================================
// Dispose 中抛异常是危险的
// ==========================================
// 如果 Dispose 抛异常，调用者的 using 块会中断
// 导致后续资源无法释放

// 反面示例
public class BadResource : IDisposable
{
    private readonly Stream _stream1;
    private readonly Stream _stream2;

    public BadResource()
    {
        _stream1 = File.OpenRead("a.txt");
        _stream2 = File.OpenRead("b.txt");
    }

    public void Dispose()
    {
        _stream1.Dispose(); // 如果这里抛异常
        _stream2.Dispose(); // 这行不会执行 → 泄漏！
    }
}

// 正确做法 — 吞掉 Dispose 中的异常或收集后一起抛出
public class GoodResource : IDisposable
{
    private readonly Stream _stream1;
    private readonly Stream _stream2;
    private bool _disposed;

    public GoodResource()
    {
        _stream1 = File.OpenRead("a.txt");
        _stream2 = File.OpenRead("b.txt");
    }

    public void Dispose()
    {
        if (_disposed) return;
        _disposed = true;

        var exceptions = new List<Exception>();

        try { _stream1.Dispose(); }
        catch (Exception ex) { exceptions.Add(ex); }

        try { _stream2.Dispose(); }
        catch (Exception ex) { exceptions.Add(ex); }

        if (exceptions.Count == 1)
            throw exceptions[0];
        if (exceptions.Count > 1)
            throw new AggregateException(exceptions);
    }
}

诊断资源泄漏

// ==========================================
// 使用 Dispose 模式检测泄漏
// ==========================================
public class LeakDetector
{
    private static readonly ConcurrentDictionary<string, int> _activeResources = new();

    public static IDisposable Track(string resourceName)
    {
        _activeResources.AddOrUpdate(
            resourceName, _ => 1, (_, count) => count + 1);
        Console.WriteLine($"[资源] 创建: {resourceName} (活跃: {_activeResources.Sum(kv => kv.Value)})");

        return new TrackedResource(resourceName);
    }

    private sealed class TrackedResource : IDisposable
    {
        private readonly string _name;
        public TrackedResource(string name) => _name = name;

        public void Dispose()
        {
            _activeResources.AddOrUpdate(
                _name, _ => 0, (_, count) => Math.Max(0, count - 1));
            Console.WriteLine($"[资源] 释放: {_name} (活跃: {_activeResources.Sum(kv => kv.Value)})");
        }
    }

    public static void Report()
    {
        foreach (var (name, count) in _activeResources)
        {
            if (count > 0)
                Console.WriteLine($"[警告] 未释放资源: {name} (数量: {count})");
        }
    }
}

// 使用 — 在开发/测试中检测泄漏
using (LeakDetector.Track("DatabaseConnection"))
{
    // 模拟资源使用
}
LeakDetector.Report();

// ==========================================
// 使用 dotnet-counters 监控
// ==========================================
// 命令行工具监控进程资源:
// dotnet-counters monitor -p <pid>
// 关注:
// - gc-heap-size        — GC 堆大小
// - gen-2-gc-count      — Gen2 GC 次数
// - gen-2-size          — Gen2 大小
// - # of Assemblies Loaded — 加载的程序集数

优点

• 1.确定性释放 — using 保证及时释放
• 2.防止泄漏 — 编译器强制检查
• 3.异步释放 — IAsyncDisposable 支持异步清理
• 4.对象复用 — 对象池减少 GC 压力
• 5.SafeHandle — 安全的非托管资源包装
• 6.终结器兜底 — 即使忘记 Dispose 也能最终释放

缺点

• 1.易遗漏 — 忘记 using 导致泄漏
• 2.终结器延迟 — GC 终结不确定
• 3.复杂度 — Dispose 模式代码量大
• 4.线程安全 — Dispose 需考虑并发调用
• 5.事件泄漏 — 不取消订阅导致引用保持
• 6.调试困难 — 资源泄漏不易复现

总结

实现 IDisposable 提供确定性资源释放，using 语句确保退出作用域时调用 Dispose()。非托管资源需要终结器作为兜底。IAsyncDisposable 支持异步资源清理。对象池复用昂贵对象减少 GC 压力。建议所有持有 IDisposable 资源的类自身也实现 IDisposable，遵循传递释放原则。

核心原则：

1. 谁创建谁释放 — 创建 IDisposable 对象的代码负责释放
2. 传递释放 — 持有 IDisposable 字段的类也要实现 IDisposable
3. using 是默认 — 任何 IDisposable 对象都应使用 using 包裹
4. 终结器是兜底 — 只有持有非托管资源时才需要终结器
5. 线程安全释放 — Dispose 应该可以安全地被多次调用

关键知识点

• 先明确这个主题影响的是语法层、运行时层，还是性能与可维护性层。
• 学习时要同时关注语言表面写法和编译器、JIT、GC 等底层行为。
• 真正有价值的是知道"为什么这样写"和"在什么边界下不能这样写"。
• WPF 主题往往要同时理解依赖属性、绑定、可视树和命令系统。

项目落地视角

• 把示例改成最小可运行样例，并观察编译输出、运行结果和异常行为。
• 如果它会进入团队代码规范，最好同步补充命名约定、禁用场景和替代方案。
• 涉及性能结论时，优先用 Benchmark 或实际热点链路验证，而不是凭感觉判断。
• 优先确认 DataContext、绑定路径、命令触发点和资源引用来源。

常见误区

• 只记语法糖，不知道底层成本。
• 把适用于小样例的写法直接搬到高并发或大对象场景里。
• 忽略框架版本、语言版本和运行时差异，导致结论失真。
• 在 code-behind 塞太多状态与业务逻辑。
• 实现 IDisposable 但忘记调用 GC.SuppressFinalize。
• 在 Dispose 中抛异常导致后续资源无法释放。
• 订阅事件但忘记取消订阅导致内存泄漏。
• Dispose 模式中disposing=false时访问托管对象。
• 混淆 Dispose() 和 DisposeAsync() 的使用场景。

进阶路线

• 继续向源码、IL、JIT 行为和 BCL 实现层深入。
• 把知识点和代码评审、性能诊断、面试复盘结合起来。
• 把同类主题做横向对比，例如值类型与引用类型、迭代器与 async 状态机、反射与 Source Generator。
• 继续补齐控件库、主题系统、诊断工具和启动性能优化。
• 学习 GC 的工作原理和代际回收机制。

适用场景

• 当你准备把《资源管理与 IDisposable》真正落到项目里时，最适合先在一个独立模块或最小样例里验证关键路径。
• 适合在需要理解语言特性、运行时行为或 API 边界时阅读。
• 当代码开始出现性能瓶颈、可维护性问题或语义歧义时，这类主题会直接影响实现质量。

落地建议

• 先写最小可运行样例，再把结论迁移到真实业务代码。
• 同时记录这个特性的收益、限制和替代方案，避免为了"高级"而使用。
• 涉及内存、并发或序列化时，最好配合调试器或基准测试验证。

排错清单

• 先确认问题属于编译期、运行期还是语义误用。
• 检查是否存在隐式转换、装箱拆箱、闭包捕获或上下文切换等隐藏成本。
• 查看异常栈、日志和最小复现代码，优先排除使用姿势问题。
• 检查所有 IDisposable 对象是否都被 using 包裹。
• 检查事件订阅是否都有对应的取消订阅。

复盘问题

• 如果把《资源管理与 IDisposable》放进你的当前项目，最先要验证的输入、输出和失败路径分别是什么？
• 《资源管理与 IDisposable》最容易在什么规模、什么边界条件下暴露问题？你会用什么指标或日志去确认？
• 相比默认实现或替代方案，采用《资源管理与 IDisposable》最大的收益和代价分别是什么？

延伸阅读

• 正则表达式实战
• 反射 Emit 动态类型生成
• 反射
• Record 类型与不可变数据