时间管理——如何应对外界的干扰

原创于 2025-11-12 15:17:33 发布 · 420 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#vJkk0

卤影薪胁我们先来看一个简单例子(Net 8)。定义一个实现了Dispose方法的简单对象Defer。然后在控制台中我们执行以下代码。

// 定义Defer类型

ref struct Defer(Action action) { public void Dispose() => action?.Invoke();}

// Main入口

static void Main(string[] args)

{

using var df = new Defer(() => Console.WriteLine("Run"));

Console.WriteLine("Hello, World!");

}

// 控制台输出：

// Hello, World!

// Run

可以看到，hello,world和Run的输出顺序反过来了。

这个Defer结构体可以近似模拟Golang中Defer关键词起到的延迟执行功能。using本身是一个语法糖，帮助我们更好把握Dispose()方法的调用时机。

对于ref struct,上述代码等效于：

{

Defer df = new Defer(() => Console.WriteLine("Run"));

try

{

Console.WriteLine("Hello, World!");

}

finally

{

df.Dispose();

}

在这里，try内部将要保住的代码为df对象生命周期以内的代码。

对于异步DisposeAsync(), using等效于：

{

ResourceType resource = ?expression?;

try

{

?statement?;

}

finally

{

IAsyncDisposable d = (IAsyncDisposable)resource;

if (d != null)

{

await d.DisposeAsync();

}

二、为什么要设计Dispose？

C#采用垃圾回收机制来自动管理内存，这使得程序员不需要手动管理内存分配和释放，大大减少了内存泄漏和野指针等问题。然而，垃圾回收器只负责托管内存的回收，对于非托管资源，它无法自动管理。而且，垃圾回收器的运行时间是不确定的，它可能在资源已经不再需要很久之后才运行。因此，需要一种机制来主动释放非托管资源，这就是Dispose出现的原因之一。

在C#开发中，我们经常使用各种资源，比如文件、数据库连接等。这些资源用完后需要及时释放，否则会占用系统资源，影响程序性能。Dispose方法就是用来释放这些资源的。当我们不再需要某个对象时，需要主动/被动的调用Dispose方法，就能把资源归还给系统，避免资源泄露。

简单来说，Dispose就是约定号的一个“用完就收拾”的方法。可以方便的配合using关键词来使用。我们可以再看看几个例子。

案例1 通过using在指定代码完成后触发Dispose：

// Main入口

using (Defer df1 = new(() => Console.WriteLine("Run")))

Console.WriteLine("Hello, World!1"); // 或通过 { ... } 包住代码

Console.WriteLine("Hello, World!2");

// 控制台输出：

// Hello, World!1

// Run

// Hello, World!2

案例2 通过using多重触发，最终按变量定义的顺序反着执行（出栈顺序）：

// Main入口

using Defer df1 = new(() => Console.WriteLine("Run1")),

df2 = new(() => Console.WriteLine("Run2")),

df3 = new(() => Console.WriteLine("Run3"));

Console.WriteLine("Hello, World!");

// 控制台输出：

// Hello, World!

// Run3

// Run2

// Run1

案例3 异步IAsyncDisposable,调用await using:

public class A_Async:IAsyncDisposable {async ValueTask IAsyncDisposable.DisposeAsync() => await Task.CompletedTask;}

static async void Main(string[] args)

{

await using A_Async a = new();

}

三、为什么要用释放模式(Dispose Pattern)？

在C#实现接口时，Visual Studio的提示中经常会弹出通过释放模式实现接口，那么什么是释放模式？

释放模式是Dispose模式和析构函数（finalizer）的结合使用，目的是为了确保资源能够被正确释放，无论是通过显式的调用Dispose方法，还是在对象被垃圾回收器（GC）回收时触发析构函数。这种模式被称为“Dispose模式”，它是一种资源管理的最佳实践，用于处理托管资源和非托管资源。

无标题

举个例子，我们有一个对象，里面有一些非托管资源，也有一些托管资源。示例代码如下：

class SampleObject:IDisposable

{

private ManagedObject _mo; //托管

private UnmanagedObject _umo; //非托管

public void Dispose() //资源释放

{

_mo.Dispose(); //释放托管

_umo.Dispose(); //释放非托管

}

3.1 防止重复调用Dispose()

正常情况下我们的代码问题不大。但假设ManagedObject和UnmanagedObject不是我们写的，所以要考虑重复Dispose可能会出现问题。为此，我们需要在SampleObject内部加上一个标志位来避免重复释放，此时代码变成了：

class SampleObject:IDisposable

{

private ManagedObject _mo;

private UnmanagedObject _umo;

private bool disposedValue = false; // 新增: flag变量

public void Dispose()

{

if (!disposedValue) // 新增: 判断flag值，避免重复调用

{

_mo.Dispose();

_umo.Dispose();

disposedValue = true;

}

3.2 避免遗漏调用Dispose()

对于含非托管资源的对象，如果忘了调用Dispose()，轻点就是内存泄漏，严重的话可能是灾难。为了确保我们的对象能够调用Dispose()，我们考虑增加析构函数。期望在程序被GC回收的时候自动释放资源，示例代码如下：

class SampleObject:IDisposable

{

private ManagedObject _mo;

private UnmanagedObject _umo;

private bool disposedValue = false;

public void Dispose()

{

DisposeFinal(); // 执行资源释放

// 新增: 如果手动调用了Dispose()，告诉终结器不要再执行析构函数

// 即不要重复调用DisposeFinal()方法

GC.SuppressFinalize(this);

}

public void DisposeFinal() //重命名，从Dispose方法中分离出来

{

if (!disposedValue)

{

_mo.Dispose();

_umo.Dispose();

disposedValue = true;

}

// 新增: 析构函数，在忘记调用Dispose()时由终结器执行Dispose()

~SampleObject()

{

DisposeFinal();

}

3.3 托管资源的提前回收

如果3.2中的对象忘了调用Dispose(),此时触发了析构函数，仍然可以执行Dispose()。

尽管看着好像一切都完美了。但这里还是有潜在的重复调用Dispose()隐患。因为终结器的执行顺序是不固定的，当SampleObject对象被终结器触发析构函数时，其他对象(比如_mo)可能也触发了析构函数。造纸在SampleObject执行Dispose时，有可能_mo的Dispose()方法被执行了2次（自身一次，外部调用一次），从而造成意外后果。

我们可以看一个例子。

3.3.1 定义一个有缺陷的托管资源类

这个类未对重复释放进行拦截。

// 我们定义一个有缺陷的托管资源的类

class ManagedData:IDisposable

{

// 模拟托管资源，大数组尽量让GC多保留一会，增加测试结果多样性

private MemoryStream data= new MemoryStream(new byte[100_000000]);

private bool _finalized = false;

int id;

public ManagedData(int id) //记录当前对象id

{

this.id = id;

}

~ManagedData()

{

_finalized = true; // 由析构函数释放

Console.WriteLine($"{id}:ManagedData 已终结.");

}

public void Dispose()

{

if (_finalized)

throw new ObjectDisposedException($"{id}:无法访问已终结的ManagedData.");

data.Dispose();

Console.WriteLine($"{id}:ManagedData 正常释放.");

_finalized = true; // 由dispose释放

}

3.3.2 定义一个继承IDisposable接口的类

再定义一个实现IDisposabled接口的SampleObject来使用。在这里我们用标准的释放模式(Dispose Pattern)来写，但故意把托管资源放到disposing判定的外面来来执行。

class SampleObject:IDisposable

{

private ManagedData _mo;

int id;

public SampleObject(int id) //记录当前对象id

{

this.id = id;

_mo = new ManagedData(id);

}

private bool disposedValue;

// 标准的释放模式写法

protected virtual void Dispose(bool disposing)

{

if (!disposedValue) //如果已执行dispose，则以下代码跳过

{

// 判定来源

// 如果是手动Dispose()调用的，disposing为true释放托管资源

// 如果是被动由终结器在析构函数调用的，disposing为false此时不应该释放托管资源

if (disposing)

{

// 本来应该写托管资源的地方

}

try

{

_mo.Dispose(); // 为了测试，这里将托管资源的释放和操作放外面

}

catch (Exception ex)

{

Console.WriteLine($"{id}:异常: {ex.GetType().Name} - {ex.Message}");

}

disposedValue = true;

}

~SampleObject()

{

Dispose(disposing: false);

}

public void Dispose()

{

Dispose(disposing: true);

GC.SuppressFinalize(this);

}

3.3.3 我们创建一些对象进行测试

尝试在一个循环中创建这个对象，然后调用GC，等待GC释放

for (int i = 0; i <5; i++)

{

new SampleObject(i); // 立即成为垃圾

}

Console.WriteLine("创建完成，开始GC...");

GC.Collect();

GC.WaitForPendingFinalizers();

Console.WriteLine($"GC完成");

Console.ReadLine(); // 需要有个暂停，等待最终打印结果

// 控制台输出

// 创建完成，开始GC...

// 0:ManagedData 已终结.

// 1:ManagedData 已终结.

// 1:异常: ObjectDisposedException - Cannot access a disposed object.

// Object name: '1:无法访问已终结的ManagedData.'.

// 2:ManagedData 正常释放.

// 2:ManagedData 已终结.

// 3:ManagedData 正常释放.

// 3:ManagedData 已终结.

// 0:异常: ObjectDisposedException - Cannot access a disposed object.

// Object name: '0:无法访问已终结的ManagedData.'.