IDisposable.Dispose IDisposable.Dispose IDisposable.Dispose IDisposable.Dispose Method

定義

執行與釋放 (Free)、釋放 (Release) 或重設 Unmanaged 資源相關聯之應用程式定義的工作。Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

public:
 void Dispose();
public void Dispose ();
abstract member Dispose : unit -> unit
Public Sub Dispose ()

範例

下列範例會顯示如何執行Dispose方法。The following example shows how you can implement the Dispose method.

#using <System.dll>
#using <System.Windows.Forms.dll>

using namespace System;
using namespace System::ComponentModel;
using namespace System::Windows::Forms;

// The following example demonstrates how to create a class that 
// implements the IDisposable interface and the IDisposable.Dispose
// method with finalization to clean up unmanaged resources. 
//
public ref class MyResource: public IDisposable
{
private:

   // Pointer to an external unmanaged resource.
   IntPtr handle;

   // A managed resource this class uses.
   Component^ component;

   // Track whether Dispose has been called.
   bool disposed;

public:
   // The class constructor.
   MyResource( IntPtr handle, Component^ component )
   {
      this->handle = handle;
      this->component = component;
      disposed = false;
   }

   // This method is called if the user explicitly disposes of the
   // object (by calling the Dispose method in other managed languages, 
   // or the destructor in C++). The compiler emits as a call to 
   // GC::SuppressFinalize( this ) for you, so there is no need to 
   // call it here.
   ~MyResource() 
   {
      // Dispose of managed resources.
      component->~Component();

      // Call C++ finalizer to clean up unmanaged resources.
      this->!MyResource();

      // Mark the class as disposed. This flag allows you to throw an
      // exception if a disposed object is accessed.
      disposed = true;
   }

   // Use interop to call the method necessary to clean up the 
   // unmanaged resource.
   //
   [System::Runtime::InteropServices::DllImport("Kernel32")]
   static Boolean CloseHandle( IntPtr handle );

   // The C++ finalizer destructor ensures that unmanaged resources get
   // released if the user releases the object without explicitly 
   // disposing of it.
   //
   !MyResource()
   {      
      // Call the appropriate methods to clean up unmanaged 
      // resources here. If disposing is false when Dispose(bool,
      // disposing) is called, only the following code is executed.
      CloseHandle( handle );
      handle = IntPtr::Zero;
   }

};

void main()
{
   // Insert code here to create and use the MyResource object.
   MyResource^ mr = gcnew MyResource((IntPtr) 42, (Component^) gcnew Button());
   mr->~MyResource();
}
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
{
    // 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.
        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;

                // Note disposing has been done.
                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.
    }
}
Imports 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 class that implements IDisposable.
   ' By implementing IDisposable, you are announcing that 
   ' instances of this type allocate scarce resources.
   Public Class MyResource
      Implements IDisposable
      ' Pointer to an external unmanaged resource.
      Private handle As IntPtr
      ' Other managed resource this class uses.
      Private component As component
      ' Track whether Dispose has been called.
      Private disposed As Boolean = False

      ' The class constructor.
      Public Sub New(ByVal handle As IntPtr)
         Me.handle = handle
      End Sub

      ' Implement IDisposable.
      ' Do not make this method virtual.
      ' A derived class should not be able to override this method.
      Public Overloads Sub Dispose() Implements IDisposable.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(Me)
      End Sub

      ' 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 Overridable Overloads Sub Dispose(ByVal disposing As Boolean)
         ' Check to see if Dispose has already been called.
         If Not Me.disposed Then
            ' If disposing equals true, dispose all managed 
            ' and unmanaged resources.
            If disposing Then
               ' Dispose managed resources.
               component.Dispose()
            End If

            ' 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

            ' Note disposing has been done.
            disposed = True

         End If
      End Sub

      ' Use interop to call the method necessary  
      ' to clean up the unmanaged resource.
      <System.Runtime.InteropServices.DllImport("Kernel32")> _
      Private Shared Function CloseHandle(ByVal handle As IntPtr) As [Boolean]
      End Function

      ' This finalizer will run only if the Dispose method 
      ' does not get called.
      ' It gives your base class the opportunity to finalize.
      ' Do not provide finalize methods in types derived from this class.
      Protected Overrides Sub Finalize()
         ' Do not re-create Dispose clean-up code here.
         ' Calling Dispose(false) is optimal in terms of
         ' readability and maintainability.
         Dispose(False)
         MyBase.Finalize()
      End Sub
   End Class

   Public Shared Sub Main()
      ' Insert code here to create
      ' and use the MyResource object.
   End Sub

End Class

備註

使用這個方法來關閉或釋放非受控資源, 例如, 檔案、資料流程和控制碼 (由執行此介面的類別實例所持有)。Use this method to close or release unmanaged resources such as files, streams, and handles held by an instance of the class that implements this interface. 依照慣例, 這個方法會用於與釋放物件所持有的資源相關聯的所有工作, 或是準備要重複使用的物件。By convention, this method is used for all tasks associated with freeing resources held by an object, or preparing an object for reuse.

警告

如果您使用的是用來IDisposable執行介面的類別, 則當您使用完類別時, 應該呼叫其Dispose實作為。If you are using a class that implements the IDisposable interface, you should call its Dispose implementation when you are finished using the class. 如需詳細資訊, 請參閱IDisposable主題中的「使用可執行 IDisposable 的物件」一節。For more information, see the "Using an object that implements IDisposable" section in the IDisposable topic.

在執行此方法時, 請確定所有保留的資源都是透過內含專案階層傳播呼叫來釋放。When implementing this method, ensure that all held resources are freed by propagating the call through the containment hierarchy. 例如, 如果物件 a 設定物件 b, 而物件 b 設定物件 C, 則的Dispose實作為必須在 B 上呼叫Dispose , Dispose而這必須在 C 上呼叫。For example, if an object A allocates an object B, and object B allocates an object C, then A's Dispose implementation must call Dispose on B, which must in turn call Dispose on C.

重要

C++編譯器支援具決定性的資源處置, 而且不允許直接執行Dispose方法。The C++ compiler supports deterministic disposal of resources and does not allow direct implementation of the Dispose method.

如果基底IDisposable類別執行, Dispose則物件也必須呼叫其基類的方法。An object must also call the Dispose method of its base class if the base class implements IDisposable. 如需在基類及其IDisposable子類別上執行的詳細資訊, 請參閱IDisposable主題中的「IDisposable 和繼承階層」一節。For more information about implementing IDisposable on a base class and its subclasses, see the "IDisposable and the inheritance hierarchy" section in the IDisposable topic.

如果物件的Dispose方法被呼叫一次以上, 物件就必須忽略第一個呼叫之後的所有呼叫。If an object's Dispose method is called more than once, the object must ignore all calls after the first one. 如果呼叫了多次的Dispose方法, 物件就不能擲回例外狀況。The object must not throw an exception if its Dispose method is called multiple times. 當資源已經處置Dispose時, 以外ObjectDisposedException的實例方法會擲回。Instance methods other than Dispose can throw an ObjectDisposedException when resources are already disposed.

使用者可能會預期資源類型使用特定慣例來表示已配置的狀態與已釋放的狀態。Users might expect a resource type to use a particular convention to denote an allocated state versus a freed state. 其中一個範例是串流類別, 傳統上會將視為開放式或已關閉。An example of this is stream classes, which are traditionally thought of as open or closed. 具有這種慣例的類別實施者可能會選擇使用自訂名稱 (例如Close) 來執行公用方法, 以Dispose呼叫方法。The implementer of a class that has such a convention might choose to implement a public method with a customized name, such as Close, that calls the Dispose method.

因為方法必須明確呼叫, 所以因為物件的取用者無法呼叫其Dispose方法, 所以一律不會釋放非受控資源。 DisposeBecause the Dispose method must be called explicitly, there is always a danger that the unmanaged resources will not be released, because the consumer of an object fails to call its Dispose method. 有兩種方式可以避免這種情況:There are two ways to avoid this:

當您使用存取非受控資源的物件 (例如StreamWriter) 時, 最好的作法是using使用語句來建立實例。When you use an object that accesses unmanaged resources, such as a StreamWriter, a good practice is to create the instance with a using statement. 語句會在使用它的程式碼完成時, 自動關閉資料流程, 並在物件上呼叫DisposeusingThe using statement automatically closes the stream and calls Dispose on the object when the code that is using it has completed. 如需範例, 請參閱StreamWriter類別。For an example, see the StreamWriter class.

適用於

另請參閱