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.

Important

C++ programmers should read Destructors and Finalizers in Visual C++. In the .NET Framework version 2.0, the C++ compiler provides support for implementing deterministic disposal of resources and does not allow direct implementation of the Dispose method.

When implementing this method, ensure that all held resources are freed by propagating the call through the containment hierarchy. 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. An object must also call the Dispose method of its base class if the base class implements IDisposable.

If an object's Dispose method is called more than once, the object must ignore all calls after the first one. The object must not throw an exception if its Dispose method is called multiple times. 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. 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.

Because the Dispose method must be called explicitly, objects that implement IDisposable must also implement a finalizer to handle freeing resources when Dispose is not called. By default, the garbage collector automatically calls an object's finalizer prior to reclaiming its memory. However, once the Dispose method has been called, it is typically unnecessary for the garbage collector to call the disposed object's finalizer. To prevent automatic finalization, Dispose implementations can call the GC.SuppressFinalize method.

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. The using statement automatically closes the stream and calls Dispose on the object when the code that is using it has completed. For an example, see the StreamWriter 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.publicclass DisposeExample
{
// A base class that implements IDisposable.// By implementing IDisposable, you are announcing that// instances of this type allocate scarce resources.publicclass 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.privatebool 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.publicvoid 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.protectedvirtualvoid 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")]
privateexternstatic 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);
}
}
publicstaticvoid Main()
{
// Insert code here to create// and use the MyResource object.
}
}