IDisposable.Dispose Method

Definition

관리되지 않는 리소스의 해제, 반환 또는 다시 설정과 관련된 애플리케이션 정의 태스크를 수행합니다.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 ()

Examples

다음 예제에서는 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

Remarks

닫거나 파일, 스트림 및이 인터페이스를 구현 하는 클래스의 인스턴스를 소유 하는 핸들 등의 관리 되지 않는 리소스를 해제 하려면이 메서드를 사용 합니다.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.

Warning

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를 호출 해야 합니다 .이는 C에서 Dispose를 호출 해야 합니다.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.

Important

컴파일러 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 메서드가 여러 번 호출 되는 경우 개체는 예외를 throw 해서는 안 됩니다.The object must not throw an exception if its Dispose method is called multiple times. Dispose 이외의 인스턴스 메서드는 리소스가 이미 삭제 된 경우 ObjectDisposedException을 throw 할 수 있습니다.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. 이러한 규칙이 있는 클래스의 구현자는 Dispose 메서드를 호출 하는 Close와 같은 사용자 지정 된 이름을 사용 하 여 공용 메서드를 구현 하도록 선택할 수 있습니다.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 메서드를 명시적으로 호출 해야 하기 때문에 개체 소비자가 해당 Dispose 메서드를 호출 하지 못하기 때문에 관리 되지 않는 리소스가 해제 되지 않을 위험이 항상 있습니다.Because 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:

  • System.Runtime.InteropServices.SafeHandle에서 파생 된 개체에 관리 되는 리소스를 래핑합니다.Wrap the managed resource in an object derived from System.Runtime.InteropServices.SafeHandle. 그러면 Dispose 구현이 System.Runtime.InteropServices.SafeHandle 인스턴스의 Dispose 메서드를 호출 합니다.Your Dispose implementation then calls the Dispose method of the System.Runtime.InteropServices.SafeHandle instances. 자세한 내용은 Object.Finalize 항목의 "SafeHandle 대체" 섹션을 참조 하세요.For more information, see "The SafeHandle alternative" section in the Object.Finalize topic.

  • Dispose가 호출 되지 않은 경우 리소스를 해제 하기 위한 종료자를 구현 합니다.Implement a finalizer to free resources when Dispose is not called. 기본적으로 가비지 수집기는 메모리를 회수 하기 전에 개체의 종료 자가 자동으로 호출 합니다.By default, the garbage collector automatically calls an object's finalizer before reclaiming its memory. 그러나 Dispose 메서드가 호출 된 경우에는 일반적으로 가비지 수집기가 삭제 된 개체의 종료자를 호출 하지 않아도 됩니다.However, if the Dispose method has been called, it is typically unnecessary for the garbage collector to call the disposed object's finalizer. 자동 종료를 방지 하기 위해 Dispose 구현은 GC.SuppressFinalize 메서드를 호출할 수 있습니다.To prevent automatic finalization, Dispose implementations can call the GC.SuppressFinalize method.

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. using 문은 스트림을 자동으로 닫고 개체를 사용 하는 코드가 완료 될 때 개체에 대 한 Dispose를 호출 합니다.The 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.

Applies to

See also