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

*/
}