正文

C#资源释放方法实例分析

︶ㄣ米米素材网 メ
米米素材网V管理员 / 阅读
0708

这篇文章主要介绍了C#资源释放方法,结合实例详细分析了C#资源释放的具体方法与相关技巧,需要的朋友可以参考下

本文实例讲述了C#资源释放方法。分享给大家供大家参考，具体如下：

1、try{}finally{}

2、using

只有类型实现了IDisposable接口并且重写Dispose()方法可以使用using语句实现资源释放.

首先来看MSDN中关于这个接口的说明：

?
1
2
3
4
5
[ComVisible(true)]
public interface IDisposable
{ // Methods
void Dispose();
}

1.[ComVisible(true)]：

指示该托管类型对 COM 是可见的.

2.此接口的主要用途是释放非托管资源。

当不再使用托管对象时，垃圾回收器会自动释放分配给该对象的内存。但无法预测进行垃圾回收的时间。另外，垃圾回收器对窗口句柄或打开的文件和流等非托管资源一无所知。将此接口的Dispose方法与垃圾回收器一起使用来显式释放非托管资源。当不再需要对象时，对象的使用者可以调用此方法。

一、基本应用

1.我们来定义一个实现了IDisposable接口的类，代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
public class TestClass :IDisposable
{
  public void DoSomething()
  {
    Console.WriteLine("Do some thing....");
  }
  public void Dispose()
  {
    Console.WriteLine("及时释放资源");
  }
}

2.我们有两种方式来调用：

2.1.第一种方式，使用Using语句会自动调用Dispose方法，代码如下：

?
1
2
3
4
using (TestClass testClass = new TestClass())
{
  testClass.DoSomething();
}

2.2第二种方式，现实调用该接口的Dispose方法，代码如下：

?
1
2
3
4
5
6
7
8
9
10
TestClass testClass = new TestClass();
try {
  testClass.DoSomething();
}
finally
{
  IDisposable disposable = testClass as IDisposable;
  if (disposable != null)
  disposable.Dispose();
}

两种方式的执行结果是一样的。

2.3.使用try/catch/finally的好处是，捕获异常后可以进行处理与此同时也可以释放资源；但是使用using,有异常也可以释放资源，只是无法对异常进行处理，直接将异常放行,而已实际上这两种方法对资源的释放上是一样的.

二、Disposable 模式

1.在.NET种由于当对象变为不可访问后将自动调用Finalize方法，所以我们手动调用IDisposable接口的Dispose方法和对象终结器调用的方法极其类似，我们最好将他们放到一起来处理。

我们首先想到的是重写Finalize方法，如下：

?
1
2
3
4
protected override void Finalize()
{
  Console.WritleLine("析构函数执行...");
}

当我们编译这段代码的时候，我们发现编译器会报如下的错误： 这是因为编译器彻底屏蔽了父类的Finalize方法，编译器提示我们如果要重写Finalize方法我们要提供一个析构函数来代替，下面我们就提供一个析构函数：

~TestClass() { Console.WriteLine("析构函数执行..."); }

实际上这个析构函数编译器会将其转变为如下代码：

?
1
2
3
4
5
6
7
8
9
protected override void Finalize()
{
  try {
    Console.WritleLine("析构函数执行...");
  }
  finally {
    base.Finalize();
  }
}

2.然后我们就可以将Dispose方法的调用和对象的终结器放在一起来处理，如下：

?
1
2
3
4
5
6
7
8
9
10
public class TestClass: IDisposable
{
  ~TestClass()
  {
    Dispose();
  }
  public void Dispose()
  { // 清理资源
  }
}

3.上面实现方式实际上调用了Dispose方法和Finalize方法，这样就有可能导致做重复的清理工作，所以就有了下面经典Disposable 模式：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
private bool _isDisposed = false;
public void Dispose()
{
  Dispose(true);
  GC.SupressFinalize(this);
}
protected void Dispose(bool Diposing)
{
  if(!_isDisposed)
  {
    if(Disposing)
    {
      //清理托管资源
    }
    //清理非托管资源
  }
  _isDisposed=true;
}
~TestClass()
{
  Dispose(false);
}

3.1. SupressFinalize方法以防止垃圾回收器对不需要终止的对象调用 Object.Finalize()。

3.2. 使用IDisposable.Dispose 方法，用户可以在可将对象作为垃圾回收之前随时释放资源。如果调用了 IDisposable.Dispose方法，此方法会释放对象的资源。这样，就没有必要进行终止。IDisposable.Dispose 应调用 GC.SuppressFinalize 以使垃圾回收器不调用对象的终结器。

3.3.我们不希望Dispose(bool Diposing)方法被外部调用，所以他的访问级别为protected 。如果Diposing为true则释放托管资源和非托管资源，如果 Diposing等于false则该方法已由运行库从终结器内部调用，并且只能释放非托管资源。

3.4.如果在对象被释放后调用其他方法，则可能会引发 ObjectDisposedException。

三、实例解析

1.下面代码对Dispose方法做了封装，说明如何在使用托管和本机资源的类中实现 Dispose(bool) 的常规示例：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
public class BaseResource : IDisposable
{
  // 非托管资源
  private IntPtr _handle;
  //托管资源
  private Component _components;
  // Dispose是否被调用
  private bool _disposed = false;
  public BaseResource() { }
  public void Dispose()
  {
    Dispose(true);
    GC.SuppressFinalize(this);
  }
  protected virtual void Dispose(bool disposing)
  {
    if (!this._disposed)
    {
      if (disposing)
      {
        // 释放托管资源
        _components.Dispose();
      }
      // 释放非托管资源，如果disposing为false, 只有非托管资源被释放
      CloseHandle(_handle);
      _handle = IntPtr.Zero;
      // 注意这里不是线程安全的
    }
    _disposed = true;
  }
  // 析构函数只会在我们没有直接调用Dispose方法的时候调用
  // 派生类中不用在次提供析构函数
  ~BaseResource() { Dispose(false); }
  // 如果你已经调用了Dispose方法后再调用其他方法会抛出ObjectDisposedException
  public void DoSomething()
  {
    if (this._disposed)
    {
      throw new ObjectDisposedException();
    }
  }
}
public class MyResourceWrapper : BaseResource
{
  // 托管资源
  private ManagedResource _addedManaged;
  // 非托管资源
  private NativeResource _addedNative;
  private bool _disposed = false;
  public MyResourceWrapper() { }
  protected override void Dispose(bool disposing)
  {
    if (!this._disposed)
    {
      try
      {
        if (disposing)
        {
          _addedManaged.Dispose();
        }
        CloseHandle(_addedNative);
        this._disposed = true;
      }
      finally
      {
        base.Dispose(disposing);
      }
    }
  }
}

2.使用CLR垃圾收集器，您不必再担心如何管理对托管堆分配的内存，不过您仍需清理其他类型的资源。托管类通过IDisposable接口使其使用方可以在垃圾收集器终结对象前释放可能很重要的资源。通过遵循disposable模式并且留意需注意的问题，类可以确保其所有资源得以正确清理，并且在直接通过Dispose调用或通过终结器线程运行清理代码时不会发生任何问题。

希望本文所述对大家C#程序设计有所帮助。