如何为类定义一个清除类对象的方法。

Question

比如:
using System;
public class ClassA
{
    public string str = "Hello";
    public void Close()
    {
        //清除对象，释放内存方法,想定义一个怎么的方法，但不知道怎么弄
    }
}
public class Program
{
    static void Main(string[] args)
    {
        ClassA ca = new ClassA();        ca = null;  //这里负责清除对象引用
        GC.Collect();         try
        {
            Console.WriteLine(ca.str);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }
}虽然说C#有垃圾回收，但有些时候还是要我们自己手动去清除对象，释放内存的。因该怎么定义这样一个方法呢。
晕晕。。不知道怎么整。

Answer 1

如果类没有使用到系统资源，比如文件，数据库连接，内在块或打开的外部设备，那么没有必要定义这样的方法。
就像是一个简单的数据类型，比如int,bool一样不需要释放一样，一般的类对象是没有必要主动释放的。如果确实使用了要施放的资源，那么类一定要继承IDisposable 接口来实际对资源的释放，请参考MSDN的关于IDisposable 接口的说明。下面是一个例子：
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
{
    // A base class that implements IDisposable.
    // By implementing IDisposable, you are announcing that 
    // instances of this type allocate scarce resources.
    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.
        private 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);
        }
    }
    public static void Main()
    {
        // Insert code here to create
        // and use the MyResource object.   
    }
}

Answer 2

对，就是要实现IDisposable接口

Answer 3

定義一個構造函數:public   class   ClassA 
{ 
        public   string   str   =   "Hello "; 
        ~ClassA()
        {
           //處理
        }
}