IDisposable接口和析构函数

using System; 
using System.ComponentModel; 
 
// The following example demonstrates how to create 
// a resource class that implements the IDisposable interface 
// and the IDisposable.Dispose method. 
 
public class DisposeExample 
{ 
 
    public class MyDisposableMember: IDisposable 
    { 
        private bool disposed = false; 
        private string info; 
 
        public MyDisposableMember(string _info) 
        { 
            info = _info; 
            System.Diagnostics.Debug.WriteLine("\tMyDisposableMember:" + info); 
        } 
 
        public void Dispose() 
        { 
            System.Diagnostics.Debug.WriteLine("\tDispose:" + info); 
            Dispose(true); 
            GC.SuppressFinalize(this); 
        } 
 
        private void Dispose(bool disposing) 
        { 
            if(!this.disposed) 
            { 
                if(disposing) 
                { 
                } 
              
            } 
 
            disposed = true;          
        } 
 
        ~MyDisposableMember()       
        { 
            System.Diagnostics.Debug.WriteLine("\t~MyDisposableMember():" + info); 
            Dispose(false); 
        } 
    } 
 
 
 
    // A base class that implements IDisposable. 
    // By implementing IDisposable, you are announcing that  
    // instances of this type allocate scarce resources. 
    public class MyResource: IDisposable 
    { 
        // Track whether Dispose has been called. 
        private bool disposed = false; 
        private string info; 
        MyDisposableMember member; 
 
        // The class constructor. 
        public MyResource(string _info) 
        { 
            info = _info; 
            System.Diagnostics.Debug.WriteLine("MyResource:" + info); 
            member = new MyDisposableMember("member-" + _info); 
        } 
 
        // Implement IDisposable. 
        // Do not make this method virtual. 
        // A derived class should not be able to override this method. 
        public void Dispose() 
        { 
            System.Diagnostics.Debug.WriteLine("Dispose:" + info); 
            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. 
        private void Dispose(bool disposing) 
        { 
            if(!this.disposed) 
            { 
                // If disposing equals true, dispose all managed  
                // and unmanaged resources. 
                if(disposing) 
                { 
                    // Dispose managed resources. 
                    member.Dispose(); 
                } 
              
                // Call the appropriate methods to clean up  
                // unmanaged resources here. 
                // If disposing is false,  
                // only the following code is executed. 
 
                member = null; 
            } 
 
            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. 
        ~MyResource()       
        { 
            // Do not re-create Dispose clean-up code here. 
            // Calling Dispose(false) is optimal in terms of 
            // readability and maintainability. 
            System.Diagnostics.Debug.WriteLine("~MyResource():" + info); 
            Dispose(false); 
        } 
    } 
    public static void Main() 
    { 
        // Insert code here to create 
        // and use the MyResource object.   
        MyResource mr = new MyResource("mr"); 
        mr.Dispose(); 
 
        new MyResource("hang"); 
 
        using(MyResource m = new MyResource("using")) 
            System.Diagnostics.Debug.WriteLine("ready to exit using statement"); 
 
        System.GC.SuppressFinalize(mr); 
    } 
 
/* 
运行结果如下： 
     
MyResource:mr 
    MyDisposableMember:member-mr 
Dispose:mr 
    Dispose:member-mr 
MyResource:hang 
    MyDisposableMember:member-hang 
MyResource:using 
    MyDisposableMember:member-using 
ready to exit using statement 
Dispose:using 
    Dispose:member-using 
    ~MyDisposableMember():member-hang 
~MyResource():hang 
 
*/ 
}