Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

IDisposable::Dispose-Methode: ()

 

Veröffentlicht: Oktober 2016

Führt anwendungsspezifische Aufgaben durch, die mit der Freigabe, der Zurückgabe oder dem Zurücksetzen von nicht verwalteten Ressourcen zusammenhängen.

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

void 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.

System_CAPS_warningWarnung

If you are using a class that implements the T:System.IDisposable interface, you should call its M:System.IDisposable.Dispose implementation when you are finished using the class. For more information, see the "Using an object that implements IDisposable" section in the T:System.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 M:System.IDisposable.Dispose implementation must call M:System.IDisposable.Dispose on B, which must in turn call M:System.IDisposable.Dispose on C.

System_CAPS_importantWichtig

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

An object must also call the M:System.IDisposable.Dispose method of its base class if the base class implements T:System.IDisposable. For more information about implementing T:System.IDisposable on a base class and its subclasses, see the "IDisposable and the inheritance hierarchy" section in the T:System.IDisposable topic.

If an object's M:System.IDisposable.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 M:System.IDisposable.Dispose method is called multiple times. Instance methods other than M:System.IDisposable.Dispose can throw an T:System.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 M:System.IDisposable.Dispose method.

Because the M:System.IDisposable.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 M:System.IDisposable.Dispose method. There are two ways to avoid this:

  • Wrap the managed resource in an object derived from T:System.Runtime.InteropServices.SafeHandle. Your M:System.IDisposable.Dispose implementation then calls the M:System.IDisposable.Dispose method of the T:System.Runtime.InteropServices.SafeHandle instances. For more information, see "The SafeHandle alternative" section in the M:System.Object.Finalize topic.

  • Implement a finalizer to free resources when M:System.IDisposable.Dispose is not called. By default, the garbage collector automatically calls an object's finalizer before reclaiming its memory. However, if the M:System.IDisposable.Dispose method has been called, it is typically unnecessary for the garbage collector to call the disposed object's finalizer. To prevent automatic finalization, M:System.IDisposable.Dispose implementations can call the M:System.GC.SuppressFinalize(System.Object) method.

When you use an object that accesses unmanaged resources, such as a T:System.IO.StreamWriter, a good practice is to create the instance with a using statement. The using statement automatically closes the stream and calls M:System.IDisposable.Dispose on the object when the code that is using it has completed. For an example, see the T:System.IO.StreamWriter class.

The following example shows how you can implement the M:System.IDisposable.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();
}

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: