.Net Dispose 模式 与 C++/CLI 确定性资源清理
1. .Net Dispose 模式
受CLI 所有语言支持，但是C++/CLI 在编译阶段进行了特殊处理，因此不要试图用C++/CLI 实现
下面的代码，实际上C++/CLI 编译器是禁止一个类显式实现System::IDisposable 接口的。C++/CLI
的处理方式将在后文讨论。
C# 实现Dispose 模式MSDN 已经说的很清楚了，网上也有不少相关资料，下面的例子给出了主要的
实现（其类），看注释就很清楚了。这里要说明的是，如果需要实现一个派生类，只需要重写带参数的
Dispose 就可以了，注意仍然需要一个bool 型变量确保资源不被多次释放，并且永远不要抛出异常。
using System;
using System.ComponentModel;
// The base class use resource
public class MyResource: IDisposable
{
// Pointer to an external unmanaged resource.
private IntPtr handle;
// Other managed resource this class uses.
private Component component = new Component();
// Track whether Dispose has been called.
private bool disposed = false;
// The class constructor.
public MyResource(IntPtr handle) {
this.handle = handle;
}
// Implement IDisposable.
// Do not make this method virtual.
// A derived class should not be able to override this method.
public void Dispose() {
Dispose(true);
// This object will be cleaned up by the Dispose method.
// Therefore, you should call GC.SupressFinalize to
// take this object off the finalization queue
// and prevent finalization code for this object
// from executing a second time.
GC.SuppressFinalize(this);
}
// Dispose(bool disposing) executes in two distinct scenarios.
// If disposing equals true, the method has been called directly
// or indirectly by a user's code. Managed and unmanaged resources
// can be disposed.
// If disposing equals false, the method has been called by the
// runtime from inside the finalizer and you should not reference
// other objects. Only unmanaged resources can be disposed.
protected virtual void Dispose(bool disposing) {
// Check to see if Dispose has already been called.
if(!this.disposed) {
// If disposing equals true, dispose all managed
// and unmanaged resources.
if(disposing) {
// Dispose managed resources.
component.Dispose();
}
// Call the appropriate methods to clean up
// unmanaged resources here.
// If disposing is false,
// only the following code is executed.
CloseHandle(handle);
handle = IntPtr.Zero;
}
disposed = true;
}
// Use interop to call the method necessary
// to clean up the unmanaged resource.
[System.Runtime.InteropServices.DllImport("Kernel32")]
private extern static Boolean CloseHandle(IntPtr handle);
// Use C# destructor syntax for finalization code.
// This destructor will run only if the Dispose method
// does not get called.
// It gives your base class the opportunity to finalize.
// Do not provide destructors in types derived from this class.
~MyResource() {
// Do not re-create Dispose clean-up code here.
// Calling Dispose(false) is optimal in terms of
// readability and maintainability.
Dispose(false);
}
}
internal static class Program
{
private static void Main() {
// Insert code here to create
// and use the MyResource object.
}
}
2. C++/CLI 确定性资源清理
C++/CLI 保留了栈对象的语义（注意只是保留了栈对象的语义，不要认为托管内存回收可以
手动控制）， 同时支持析构器与终结器，对资源清理采取的手法比其他.Net语言有些特殊。下面这句话
出自MSDN：
Destructors in a reference type perform deterministic clean up of your
resources. Finalizers clean up unmanaged resources and can be called
deterministically by the destructor or non-deterministically by the garbage
collector.
因此在析构器里面应该清除托管资源，在终结器里面应该清除非托管资源。为了避免代码重复，
MSDN推荐在析构器里清理托管资源外，最后调用终结器。
一个C++/CLI 类中同时定义析构器与终结器（如下面的声明）
ref class T
{
~T()；// Destructor
!T()；// Finalizer
};
语义为：
void Dispose(bool disposing)
{
if (disposing) {
~T();
} else {
!T();
}
}
结合Dispose模式，就不难理解为何要在析构器里调用终结器了。
废话不多说，举例如下：
#include <vcclr.h>
#include <stdio.h>
using namespace System;
using namespace System::IO;
ref class SystemFileWriter
{
public:
SystemFileWriter(String^ name) : file(File::Open(name, FileMode::Append)),
arr(gcnew array<Byte>(10)) {
for (int i = 0; i < arr->Length; i++) {
arr[i] = (Byte)'A';
}
}
void WriteToFile() {
file->Write(arr, 0, arr->Length);
}
~SystemFileWriter() {
delete file;
}
private:
FileStream^ file;
array<Byte>^ arr;
};
ref class CRTFileWriter
{
public:
CRTFileWriter(String^ name) : file(getFile(name)),
arr(gcnew array<Byte>(10)), disposed(false) {
for (int i = 0; i < arr->Length; i++) {
arr[i] = (Byte)'B';
}
}
void WriteToFile() {
pin_ptr<Byte> buf = &arr[0];
fwrite(buf, 1, arr->Length, file);
}
~CRTFileWriter() {
if (!disposed) {
this->!CRTFileWriter();
disposed = true;
}
}
!CRTFileWriter() {
fclose(file);
}
private:
FILE* file;
array<Byte>^ arr;
bool disposed;
static FILE* getFile(String ^ n) {
pin_ptr<const wchar_t> name = PtrToStringChars(n);
FILE* ret = 0;
_wfopen_s(&ret, name, L"ab");
return ret;
}
};
int main() {
// 推荐写法，利用栈对象语义清理资源
SystemFileWriter w1("systest.txt");
w1.WriteToFile();
// 这种写法用完后一般应该调用delete
CRTFileWriter^ w2 = gcnew CRTFileWriter("crttest.txt");
try {
w2->WriteToFile();
}
finally {
delete w2;
}
return 0;
}
类SystemFileWriter 利用.Net BCL 的System::IO::FileStream 来写文件，
虽然 FileStream 内部也使用了文件句柄（非托管资源），但是FileStream本身会处理这个句柄，
所以它应该被视为托管资源。那么就应该在析构器里面调用delete ，而不应该在终结器里调用，因
为终结器是由垃圾收集器调用的，可能在它调用时，file的句柄已经被释放了，导致异常的发生。
类CRTFileWriter 使用的File 句柄是非托管资源，垃圾收集器不知道怎么关闭它，因此
要在终结器采取关闭操作。如果客户代码调用了使用后调用了delete 或者使用栈对象语义，栈清空时，
析构器会调用，并且编译器已经在析构器最后添加了GC.SuppriseFinalize(this); 从终结队列里
移除了，所以不必担心会增加垃圾对象的代从而增加垃圾收集器的压力。资源回收完全可以手动控制, 这
就是所谓的确定性资源清理。
如果客户代码使用了追踪句柄创建了引用类型，而忘记调用delete，那么析构器会在某个时
刻被调用从而做关闭文件句柄的操作，此时会增加文件句柄被占用的时间和增加托管堆的压力。
最后补充一点，在C++/CLI 里，一个类终结器的调用不会自动调用基类及类层次结构的终结器，
因此处理基类与处理派生类具有一致性（不像C#等其他.Net语言的Dispose模式）。
