Was this page helpful?
Your feedback about this content is important. Let us know what you think.
Additional feedback?
1500 characters remaining
Dispose Method
Collapse the table of content
Expand the table of content

IDisposable.Dispose Method

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)

Sub Dispose

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.

Caution noteCaution

If you are using a class that implements the IDisposable interface, you should call its Dispose 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's Dispose implementation must call Dispose on B, which must in turn call Dispose on C.

Important noteImportant

The C++ compiler supports deterministic disposal of resources and does not allow direct implementation of the Dispose method.

An object must also call the Dispose method of its base class if the base class implements 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.

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, 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:

  • Wrap the managed resource in an object derived from System.Runtime.InteropServices.SafeHandle. Your Dispose implementation then calls the Dispose 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 Dispose is not called. By default, the garbage collector automatically calls an object's finalizer before reclaiming its memory. However, if 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.

The following example shows how you can implement the Dispose method.

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
         ' 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.
      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.
            End If 

            ' Call the appropriate methods to clean up  
            ' unmanaged resources here. 
            ' If disposing is false,  
            ' only the following code is executed.
            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.
      End Sub 
   End Class 

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

End Class

.NET Framework

Supported in: 4.6, 4.5, 4, 3.5, 3.0, 2.0, 1.1

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

XNA Framework

Supported in: 3.0, 2.0, 1.0

.NET for Windows Phone apps

Supported in: Windows Phone 8.1, Windows Phone Silverlight 8.1, Windows Phone Silverlight 8

Portable Class Library

Supported in: Portable Class Library
© 2015 Microsoft