IDisposable.Dispose Method ()
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
Assembly: mscorlib (in mscorlib.dll)
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.
If you are using a class that implements the IDisposable interface, you should call its implementation when you are finished using the class. 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. For example, if an object A allocates an object B, and object B allocates an object C, then A'simplementation must call on B, which must in turn call on C.
The C++ compiler supports deterministic disposal of resources and does not allow direct implementation of themethod.
An object must also call the 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.method of its base class if the base class implements
If an object's ObjectDisposedException when resources are already disposed.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 method is called multiple times. Instance methods other than can throw an
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 method.
Because themethod 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 method. There are two ways to avoid this:
Wrap the managed resource in an object derived from System.Runtime.InteropServices.SafeHandle. Your implementation then calls the method of the System.Runtime.InteropServices.SafeHandle instances. For more information, see "The SafeHandle alternative" section in the Object.Finalize topic.
Implement a finalizer to free resources when GC.SuppressFinalize method.is not called. By default, the garbage collector automatically calls an object's finalizer before reclaiming its memory. However, if the method has been called, it is typically unnecessary for the garbage collector to call the disposed object's finalizer. To prevent automatic finalization, implementations can call the
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 on the object when the code that is using it has completed. For an example, see the StreamWriter class.
Available since 4.5
Available since 1.1
Portable Class Library
Supported in: portable .NET platforms
Available since 2.0
Windows Phone Silverlight
Available since 7.0
Available since 8.1