IDisposable.Dispose 메서드
관리되지 않는 리소스의 확보, 해제 또는 다시 설정과 관련된 응용 프로그램 정의 작업을 수행합니다.
네임스페이스: System
어셈블리: mscorlib(mscorlib.dll)
구문
‘선언
Sub Dispose
‘사용 방법
Dim instance As IDisposable
instance.Dispose
void Dispose ()
void Dispose ()
void Dispose ()
function Dispose ()
설명
이 인터페이스를 구현하는 클래스의 인스턴스에서 보유하는 파일, 스트림 및 핸들 등과 같은 관리되지 않는 리소스를 닫거나 해제하려면 이 메서드를 사용합니다. 일반적으로 이 메서드는 개체에서 보유하는 리소스를 확보하거나 다시 사용할 수 있도록 개체를 준비하는 것과 관련된 모든 작업에 사용됩니다.
중요
C++ 프로그래머는 Destructors and Finalizers in Visual C++를 참조하십시오. .NET Framework 버전 2.0에서 C++ 컴파일러는 리소스를 명확하게 해제하기 위한 구현을 지원하며 Dispose 메서드의 직접 구현은 허용되지 않습니다.
이 메서드를 구현하는 경우 포함 계층 구조를 통해 호출을 전파하여 모든 보유 리소스가 확보되는지 확인합니다. 예를 들어, A 개체가 B 개체를 할당하고 B 개체가 C 개체를 할당하는 경우 A의 Dispose 구현은 B에 대해 Dispose를 호출한 다음 다시 C에 대해 Dispose를 호출해야 합니다. 개체는 기본 클래스가 IDisposable을 구현하는 경우에도 해당 기본 클래스의 Dispose 메서드를 호출해야 합니다.
개체의 Dispose 메서드가 두 번 이상 호출되면, 해당 개체는 첫 번째 호출 이후의 모든 호출을 무시해야 합니다. Dispose 메서드가 여러 번 호출되는 경우 개체는 예외를 throw하지 않아야 합니다. Dispose 이외의 인스턴스 메서드는 리소스가 이미 삭제된 경우 ObjectDisposedException을 throw할 수 있습니다.
리소스 형식은 특정 규칙을 사용하여 할당 상태와 확보 상태를 나타낼 수 있습니다. 예로 열려 있거나 닫혀 있는 것으로 간주되는 스트림 클래스를 들 수 있습니다. 이러한 규칙이 적용된 클래스의 구현자는 Dispose 메서드를 호출하는 공용 메서드를 구현하고 Close와 같은 사용자 지정된 이름을 지정할 수 있습니다.
Dispose 메서드는 명시적으로 호출되어야 하므로 IDisposable를 구현하는 개체도 Dispose가 호출되지 않은 경우에 확보된 리소스를 처리하기 위한 종료자를 구현해야 합니다. 기본적으로 가비지 수집기는 메모리를 회수하기 전에 개체의 종료자를 자동으로 호출합니다. 그러나 Dispose 메서드를 호출하면 일반적으로 가비지 수집기에서 삭제된 개체의 종료자를 호출할 필요가 없습니다. 자동 종료를 방지하기 위해 Dispose 구현 중에 GC.SuppressFinalize 메서드를 호출할 수 있습니다.
Dispose 메서드와 종료자 구현에 대한 자세한 내용은 GC 클래스, Object.Finalize 메서드 및 Finalize 및 Dispose를 구현하여 관리되지 않는 리소스 정리를 참조하십시오.
예제
Imports System
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.
Private 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
End If
disposed = True
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
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.
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.
}
}
#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();
}
import System.*;
import 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 static class MyResource implements 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 boolean disposed = false;
// The class constructor.
public MyResource(IntPtr handle)
{
this.handle = handle;
} //MyResource
// 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
// 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(boolean 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;
} //Dispose
// Use interop to call the method necessary
// to clean up the unmanaged resource.
/** @attribute System.Runtime.InteropServices.DllImport("Kernel32")
*/
private static native Boolean CloseHandle(IntPtr handle);
// Use J# 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.
public void finalize()
{
// Do not re-create Dispose clean-up code here.
// Calling Dispose(false) is optimal in terms of
// readability and maintainability.
Dispose(false);
try {
super.finalize();
}
catch(System.Exception e ) {
}
} //finalize
} //MyResource
public static void main(String[] args)
{
// Insert code here to create
// and use the MyResource object.
} //main
} //DisposeExample
플랫폼
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework에서 모든 플래폼의 모든 버전을 지원하지는 않습니다. 지원되는 버전의 목록은 시스템 요구 사항을 참조하십시오.
버전 정보
.NET Framework
2.0, 1.1, 1.0에서 지원
.NET Compact Framework
2.0, 1.0에서 지원