net C# 如何理解和实现 Dispose 方法
.net C# 如何理解和实现 Dispose 方法
1、接口 IDisposable
接口 IDisposable 包含了一个名为 Dispose 的方法。
namespace System;
public interface IDisposable
{
void Dispose();
}
实现了接口 IDisposable 的类，才可以使用 using 语句进行调用，以实现资源的释放，否则将报错错，提示：using 语句中使用的类型必须实现 System.IDisposable。
public class DbHelper : IDisposable
{
//...
public void Dispose()
{
//...
}
}
// 使用 using 语句进行调用
using (var helper = new DbHelper())
{
//...
}
// 使用 using 语句编译后等价于
DbHelper helper = null;
try
{
helper = new DbHelper();
//...
}
finally
{
helper?.Dispose();
}
2、析构函数
C# 编译器不会为没有显式定义析构函数的类自动生成析构函数。只有当你显式定义了析构函数（~ClassName()）时，编译器才会生成 Finalize 方法【析构函数是 C# 语法糖，最终编译为 Finalize 方法】。
析构函数的调用时机不可控。析构函数将仅用于释放非拖管资源。拖管资源由 GC 进行释放，释放时机和顺序不可控。若拖管资源再由析构函数来释放，则可能导致程序崩溃：已释放的资源（不存在的资源）在析构函数中再次被释放。
功能上，析构函数与 Dispose 方法重复进行了相同的工作。但二者角色不同，在实际的开发实践中，析构函数通常用于对忘记主动调用 Dispose 方法的补救。
因此，最佳实践是，将释放工作交给另一个方法 void Dispose(bool disposing)，然后通过disposing 进行区分，到底调用是来自 Dispose 方法还是来自析构函数。示例如下：
public class DbHelper : IDisposable
{
//...
public void Dispose()
{
Dispose(true);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
// 释放托管资源
// ...
}
// 释放非托管资源（无论手动/GC 都必须执行）
// ...
}
~DbHelper()
{
Dispose(false);
}
}
3、实现幂等
所谓幂等，即函数被调用次数不同，不影响结果。即，无论调用多少次，结果完全一样，不会报错、不会崩溃。
Dispose 方法必须实现幂等，因为代码里可能不小心多次调用 Dispose 方法。如果不做幂等，程序会报错、崩溃、资源重复释放。最佳实践中，资源释放工作交给了 void Dispose(bool disposing)，因此，void Dispose(bool disposing) 实现幂等即可。
实现幂等的方式，比较简单，即如果已经释放资源，则不再进行资源释放工作，通过字段 private bool _disposed = false; 来实现。
public class DbHelper : IDisposable
{
//...
public void Dispose()
{
Dispose(true);
}
// 实现幂等的关键字段：
private bool _disposed = false;
protected virtual void Dispose(bool disposing)
{
//如果已经释放资源，则不再进行资源释放工作
if (_disposed) { return; }
if (disposing)
{
// 释放托管资源
// ...
}
// 释放非托管资源（无论手动/GC 都必须执行）
// ...
_disposed = true;
}
~DbHelper()
{
Dispose(false);
}
}
4、继承时的资源释放
继承时，子类是需要释放父类实现中所占用的资源。因此，void Dispose(bool disposing) 最好应用 protected virtual 进行修饰，以便子类调用。
另，子类的 void Dispose(bool disposing) 也应具有幂等特性。在该方法上，父类与子类，应各自维护自己的幂等特性。
当类不需要被继承时（ sealed 类），可以简化 Dispose 模式，即不需要用 virtual 修饰方法。
以下是子类示例：
public class Derived : DbHelper
{
// 其他 Derived 类特有的成员
// 注意：不要重新实现 Dispose() 方法，因为基类已经实现了 IDisposable
// 如果重新实现，会隐藏基类的 Dispose()，导致通过基类引用和子类引用调用 Dispose() 时行为不一致，破坏多态性。
// 只需重写 void Dispose(bool disposing) 方法即可
//public void Dispose()
//{
// Dispose(true);
//}
// 子类也应使 override 的 Dispose(bool disposing)实现幂等
private bool _disposed = false;
protected override void Dispose(bool disposing)
{
//如果已经释放资源，则不再进行资源释放工作
if (_disposed) { return; }
if (disposing)
{
// 释放 Derived 类特有的托管资源
// ...
}
// 释放 Derived 类特有的非托管资源（无论手动/GC 都必须执行）
// ...
// 调用基类的 Dispose 方法，确保基类资源也得到释放
base.Dispose(disposing);
_disposed = true;
}
// 子类不必实现析构函数，因为父类有析构函数。在析构的过程中，子类析构函数执行先于父类析构函数。
// 但无论如何，父类析构函数总会执行，又因为 override 了 void Dispose(bool disposing) 的缘故，
// 父类的析构函数中 Dispose(false) 语句，由于类的多态特性，将调用子类的 void Dispose(bool disposing) 方法。
// 仅调用 Dispose(false) 的子类析构函数，是冗余的。
//~Derived()
//{
// Dispose(false);
//}
}
5、性能改善
有析构函数的对象会被放入 Finalization 队列，增加 GC 负担。
Dispose 方法用于主动地立即地资源释放，当我们主动释放资源后，垃圾回收器并不知情，因此需要知会垃圾回收器，请求不必调用终结器。
当类没有实现析构函数，不通过其进行兜底时，则不必知会垃圾回收器。如果没有析构函数，GC.SuppressFinalize(this);则是无意义的。
高性能场景：避免使用析构函数。
public void Dispose()
{
Dispose(true);
// 请求系统不要调用这个对象的终结器，以提高性能
GC.SuppressFinalize(this);
}
6、其他注意事项
（1）异常处理
禁止在 Dispose 中抛异常。因为可能会导致（编译生成的等效的） finally 块执行中断，进而资源泄漏，违背释放资源的初衷。
（2）设置为 null
纯托管对象（如 List<T>），不需要手动释放，GC 会自动回收，设置为 null 不会立即释放内存，但可以断开引用，帮助 GC 更早发现对象不可达。其他的，如实现 IDisposable 的托管对象、非托管资源以及静态资源等，直接设置为 null 是无效的释放资源。
（3）字段 _disposed
它作为对象的字段存在，布尔类型，在系统调用析构函数时，它仍然没有消失，仍处理生命周期内。
（4）ObjectDisposedException
主动调用 Dispose 方法后，对象可能还在其生命周期中。如果此时调用对象的其他方法，则可能产生未知的错误。因此，需要在其他方法中检查是否已经释放资源。
public class DbHelper : IDisposable
{
private bool _disposed = false;
public void ExecuteQuery(string sql)
{
if (_disposed)
{
throw new ObjectDisposedException(nameof(DbHelper));
}
// 正常执行逻辑
}
}
如果可行，最好在调用 Dispose 方法后，立即将对象设置为 null。
if (disposing)
{
_managedResource?.Dispose();
_managedResource = null;
}
（5）线程安全
当需要时，void Dispose(bool disposing) 应实现其线程安全，避免多线程同时进入该方法从而导致错误发生。
protected virtual void Dispose(bool disposing)
{
lock (_lockObject)
{
if (_disposed) { return; }
if (disposing)
{
// 释放 Derived 类特有的托管资源
// ...
}
// 释放 Derived 类特有的非托管资源
// ...
base.Dispose(disposing);
_disposed = true;
}
}
除使用上述锁方式外，还可使用 Interlocked 进行。
// 使用 Interlocked 的轻量级实现
private int _disposed = 0;
protected virtual void Dispose(bool disposing)
{
if (Interlocked.Exchange(ref _disposed, 1) == 0)
{
if (disposing)
{
// 释放托管资源
}
// 释放 Derived 类特有的非托管资源
// ...
// 释放非托管资源
base.Dispose(disposing);
}
}
（6）异步释放
.NET Core 3.0+ 引入了异步释放模式，对于需要异步释放资源的场景（如异步文件操作、网络连接等）非常重要。
通过实现接口 IAsyncDisposable 的 DisposeAsync 方法的方式，提供了一种异步释放非托管资源的机制。
关于 异步释放资源的实现 与注意事项，此处略。
namespace System
{
public interface IAsyncDisposable
{
// 返回结果: 一个 task ，用于异步释放操作.
ValueTask DisposeAsync();// 非托管资源释放、异步释放或重置
}
}
（7）一般情况
一般来说，实现了接口IDisposable 的类的实例，其释放应放在 disposing = true 中进行，因为它们已具有析构函数进行兜底。例如，数据库的连接的关闭。
部分类（如 DbConnection）有 Close 方法，本质是 Dispose 的封装。
if (disposing)
{
_managedResource?.Dispose();
_managedResource = null;
SqliteConn.Close();
}
7、完整示例
public class DbHelper : IDisposable
{
//...
public void ExecuteQuery(string sql)
{
if (_disposed)
{
throw new ObjectDisposedException(nameof(DbHelper));
}
// 正常执行逻辑
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
private bool _disposed = false;
protected readonly object _lockObject = new object();
protected virtual void Dispose(bool disposing)
{
lock (_lockObject)
{
if (_disposed) { return; }
if (disposing)
{
// 释放托管资源
// ...
}
// 释放非托管资源
// ...
_disposed = true;
}
}
~DbHelper()
{
Dispose(false);
}
}
public class Derived : DbHelper
{
// 其他 Derived 类特有的成员
//...
private bool _disposed = false;
protected override void Dispose(bool disposing)
{
//基类和子类使用相同的锁对象，保证整个释放过程是原子的
lock (_lockObject)
{
if (_disposed) { return; }
if (disposing)
{
// 释放 Derived 类特有的托管资源
// ...
}
// 释放 Derived 类特有的非托管资源
// ...
base.Dispose(disposing);
_disposed = true;
}
}
}
浙公网安备 33010602011771号