浅析C# Dispose方法的实现

// Design pattern for the base class.  
// By implementing IDisposable, you are announcing that instances  
// of this type allocate scarce resources.  
public class BaseResource: IDisposable  
{  
// Pointer to an external unmanaged resource.  
private IntPtr handle;  
// Other managed resource this class uses.  
private Component Components;  
// Track whether Dispose has been called.  
private bool disposed = false;  
 
// Constructor for the BaseResource object.  
public BaseResource()  
{  
// Insert appropriate constructor code here.  
}  
 
// Implement IDisposable.  
// Do not make this method virtual.  
// A derived class should not be able to override this method.  
public void Dispose()  
{  
Dispose(true);  
// Take yourself off the Finalization queue   
// to 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.  
Components.Dispose();  
}  
// Release unmanaged resources. If disposing is false,   
// only the following code is executed.  
CloseHandle(handle);  
handle = IntPtr.Zero;  
// Note that this is not thread safe.  
// Another thread could start disposing the object  
// after the managed resources are disposed,  
// but before the disposed flag is set to true.  
// If thread safety is necessary, it must be  
// implemented by the client.  
 
}  
disposed = true;  
}  
 
// 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.  
~BaseResource()  
{  
// Do not re-create Dispose clean-up code here.  
// Calling Dispose(false) is optimal in terms of  
// readability and maintainability.  
Dispose(false);  
}  
 
// Allow your Dispose method to be called multiple times,  
// but throw an exception if the object has been disposed.  
// Whenever you do something with this class,   
// check to see if it has been disposed.  
public void DoSomething()  
{  
if(this.disposed)  
{  
throw new ObjectDisposedException();  
}  
}  
}  
 
// Design pattern for a derived class.  
// Note that this derived class inherently implements the   
// IDisposable interface because it is implemented in the base class.  
public class MyResourceWrapper: BaseResource  
{  
// A managed resource that you add in this derived class.  
private ManagedResource addedManaged;  
// A native unmanaged resource that you add in this derived class.  
private NativeResource addedNative;  
private bool disposed = false;  
 
  // Constructor for this object.  
public MyResourceWrapper()  
{  
// Insert appropriate constructor code here.  
}  
 
protected override void Dispose(bool disposing)  
{  
if(!this.disposed)  
{  
try 
{  
if(disposing)  
{  
// Release the managed resources you added in  
// this derived class here.  
addedManaged.Dispose();  
}  
// Release the native unmanaged resources you added  
// in this derived class here.  
CloseHandle(addedNative);  
this.disposed = true;  
}  
finally 
{  
// Call Dispose on your base class.  
base.Dispose(disposing);  
}  
}  
}  
}  
 
// This derived class does not have a Finalize method  
// or a Dispose method without parameters because it inherits   
// them from the base class.  
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.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.