Markieren Sie das Kontrollkästchen Englisch, um die englische Version dieses Artikels anzuzeigen. Sie können den englischen Text auch in einem Popup-Fenster einblenden, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch
Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

IDisposable-Schnittstelle

Definiert eine Methode zur Freigabe von reservierten Ressourcen.

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

[ComVisibleAttribute(true)]
public interface IDisposable

Der IDisposable-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA Frameworkaax125c9.PortableClassLibrary(de-de,VS.100).gifDisposeFührt anwendungsspezifische Aufgaben aus, die mit dem Freigeben, Zurückgeben oder Zurücksetzen von nicht verwalteten Ressourcen zusammenhängen.
Zum Seitenanfang

Über diese Schnittstelle werden hauptsächlich nicht verwaltete Ressourcen freigegeben. Der Garbage Collector gibt automatisch den für ein verwaltetes Objekt belegten Speicher frei, wenn dieses Objekt nicht mehr verwendet wird. Es kann allerdings nicht vorausgesagt werden, wann die Garbage Collection stattfindet. Darüber hinaus hat der Garbage Collector keine Kenntnis von nicht verwalteten Ressourcen wie Fensterhandles oder offenen Dateien und Streams.

Mit der Dispose-Methode dieser Schnittstelle können nicht verwaltete Ressourcen in Verbindung mit dem Garbage Collector explizit freigegeben werden. Der Consumer eines Objekts kann diese Methode aufrufen, wenn das Objekt nicht mehr benötigt wird.

Beim Hinzufügen der IDisposable-Schnittstelle zu einer vorhandenen Klasse wird die Version verlassen, da hierbei die Semantik der Klasse geändert wird.

Wichtiger HinweisWichtig

C++-Programmierer sollten Destructors and Finalizers in Visual C++ lesen. In der .NET Framework-Version unterstützt der C++-Compiler das Implementieren der deterministischen Freigabe von Ressourcen und verhindert das direkte Implementieren der Dispose-Methode.

Eine ausführliche Beschreibung der Verwendung dieser Schnittstelle und der Object.Finalize-Methode finden Sie unter den Themen zu Garbage Collection und Implementieren einer Dispose-Methode.

Aufrufen der IDisposable-Schnittstelle

Verwenden Sie für den Aufruf einer Klasse, die die IDisposable-Schnittstelle implementiert, einen try-finally-Block, um sicherzustellen, dass nicht verwaltete Ressourcen auch dann freigegeben werden, wenn die Anwendung aufgrund einer Ausnahme beendet wird.

Weitere Informationen zum try/finally-Block finden Sie unter Try...Catch...Finally-Anweisung (Visual Basic), try-finally (C#-Referenz) und try-finally Statement (C).

Beachten Sie, dass Sie die using-Anweisung (Using in Visual Basic) anstelle eines try-finally-Blocks verwenden können. Weitere Informationen finden Sie in der Dokumentation zu Using-Anweisung (Visual Basic) und der Dokumentation zu using-Anweisung (C#-Referenz).

Im folgenden Beispiel wird das Erstellen einer Ressourcenklasse veranschaulicht, die die IDisposable-Schnittstelle verwendet.


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.
        protected virtual 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;

                // 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")]
        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.
    }
}


.NET Framework

Unterstützt in: 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Unterstützt in:

Windows 7, Windows Vista SP1 oder höher, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (Server Core wird nicht unterstützt), Windows Server 2008 R2 (Server Core wird mit SP1 oder höher unterstützt), Windows Server 2003 SP2

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.
Anzeigen: