IDisposable Schnittstelle

Definition

Stellt einen Mechanismus für die Freigabe nicht verwalteter Ressourcen bereit.Provides a mechanism for releasing unmanaged resources.

public interface class IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public interface IDisposable
type IDisposable = interface
Public Interface IDisposable
Abgeleitet
Attribute

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie eine Ressourcen Klasse erstellt wird, IDisposable die die-Schnittstelle implementiert.The following example demonstrates how to create a resource class that implements the IDisposable interface.

#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();
}
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.
    }
}
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
         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(Me)
      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.
               component.Dispose()
            End If

            ' 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

         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.
         Dispose(False)
         MyBase.Finalize()
      End Sub
   End Class

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

End Class

Hinweise

Die primäre Verwendung dieser Schnittstelle besteht darin, nicht verwaltete Ressourcen freizugeben.The primary use of this interface is to release unmanaged resources. Der Garbage Collector gibt den Arbeitsspeicher, der einem verwalteten Objekt zugeordnet ist, automatisch frei, wenn dieses Objekt nicht mehr verwendet wird.The garbage collector automatically releases the memory allocated to a managed object when that object is no longer used. Es ist jedoch nicht möglich, vorherzusagen, wann Garbage Collection auftreten werden.However, it is not possible to predict when garbage collection will occur. Außerdem hat der Garbage Collector keine Kenntnis von nicht verwalteten Ressourcen wie z. b. Fenster Handles oder geöffneten Dateien und Streams.Furthermore, the garbage collector has no knowledge of unmanaged resources such as window handles, or open files and streams.

Verwenden Sie Dispose die-Methode dieser Schnittstelle, um nicht verwaltete Ressourcen in Verbindung mit dem Garbage Collector explizit freizugeben.Use the Dispose method of this interface to explicitly release unmanaged resources in conjunction with the garbage collector. Der Consumer eines Objekts kann diese Methode aufzurufen, wenn das Objekt nicht mehr benötigt wird.The consumer of an object can call this method when the object is no longer needed.

Warnung

Es ist eine Breaking Change, die IDisposable -Schnittstelle zu einer vorhandenen Klasse hinzuzufügen.It is a breaking change to add the IDisposable interface to an existing class. Da bereits vorhandene Consumer ihres Typs nicht aufgerufen Disposewerden können, können Sie nicht sicher sein, dass nicht verwaltete Ressourcen, die von Ihrem Typ aufbewahrt werden, freigegeben werden.Because pre-existing consumers of your type cannot call Dispose, you cannot be certain that unmanaged resources held by your type will be released.

Da die IDisposable.Dispose -Implementierung vom Consumer eines Typs aufgerufen wird, wenn die Ressourcen, die sich im Besitz einer Instanz befinden, nicht mehr benötigt werden, sollten Sie entweder das SafeHandle verwaltete Objekt in einer (die empfohlene Alternative) einschließen oder überschreiben Object.Finalize., wenn nicht verwaltete Ressourcen freigegeben werden sollen, wenn der Consumer vergisst Dispose, aufzurufen.Because the IDisposable.Dispose implementation is called by the consumer of a type when the resources owned by an instance are no longer needed, you should either wrap the managed object in a SafeHandle (the recommended alternative), or you should override Object.Finalize to free unmanaged resources in the event that the consumer forgets to call Dispose.

Wichtig

Im .NET Framework unterstützt der C++ Compiler die deterministische Freigabe von Ressourcen und lässt keine direkte Implementierung Dispose der-Methode zu.In the .NET Framework, the C++ compiler supports deterministic disposal of resources and does not allow direct implementation of the Dispose method.

Ausführliche Informationen zur Verwendung dieser Schnittstelle und der Object.Finalize -Methode finden Sie in den Themen zur automatischen Speicher Bereinigung und zur Implementierung einer verwerfen-Methode.For a detailed discussion about how this interface and the Object.Finalize method are used, see the Garbage Collection and Implementing a Dispose Method topics.

Verwenden eines Objekts, das iverwerfimplementiertUsing an object that implements IDisposable

Wenn Ihre APP einfach ein Objekt verwendet, das die IDisposable -Schnittstelle implementiert, sollten Sie die IDisposable.Dispose -Implementierung des Objekts abrufen, wenn Sie die Verwendung abgeschlossen haben.If your app simply uses an object that implements the IDisposable interface, you should call the object's IDisposable.Dispose implementation when you are finished using it. Abhängig von ihrer Programmiersprache können Sie dies auf zwei Arten erreichen:Depending on your programming language, you can do this in one of two ways:

  • Mithilfe eines sprach Konstrukts, wie z using . b C# . der-Anweisung in und Visual Basic.By using a language construct such as the using statement in C# and Visual Basic.

  • Durch IDisposable.Dispose Umpacken des Aufrufes in einen-Block in einen try / finally -Block.By wrapping the call to the IDisposable.Dispose implementation in a try/finally block.

Hinweis

Dokumentation für Typen, die IDisposable implementieren, beachten Sie, dass diese Tatsache und eine Dispose Erinnerung enthalten, um die Implementierung aufzurufen.Documentation for types that implement IDisposable note that fact and include a reminder to call its Dispose implementation.

Die C# -und-Visual Basic using-AnweisungThe C# and Visual Basic Using statement

Wenn Ihre Sprache ein Konstrukt wie die using -Anweisung in C# und die using -Anweisung in Visual Basic unterstützt, können Sie Sie anstelle eines expliziten Aufruf IDisposable.Dispose von verwenden.If your language supports a construct such as the using statement in C# and the Using statement in Visual Basic, you can use it instead of explicitly calling IDisposable.Dispose yourself. Im folgenden Beispiel wird dieser Ansatz verwendet, um WordCount eine Klasse zu definieren, die Informationen über eine Datei und die Anzahl der darin aufgeführten Wörter beibehält.The following example uses this approach in defining a WordCount class that preserves information about a file and the number of words in it.

using System;
using System.IO;
using System.Text.RegularExpressions;

public class WordCount
{
   private String filename = String.Empty;
   private int nWords = 0;
   private String pattern = @"\b\w+\b"; 

   public WordCount(string filename)
   {
      if (! File.Exists(filename))
         throw new FileNotFoundException("The file does not exist.");
      
      this.filename = filename;
      string txt = String.Empty;
      using (StreamReader sr = new StreamReader(filename)) {
         txt = sr.ReadToEnd();
      }
      nWords = Regex.Matches(txt, pattern).Count;
   }
   
   public string FullName
   { get { return filename; } }
   
   public string Name
   { get { return Path.GetFileName(filename); } }
   
   public int Count 
   { get { return nWords; } }
}   
Imports System.IO
Imports System.Text.RegularExpressions

Public Class WordCount
   Private filename As String
   Private nWords As Integer
   Private pattern As String = "\b\w+\b" 

   Public Sub New(filename As String)
      If Not File.Exists(filename) Then
         Throw New FileNotFoundException("The file does not exist.")
      End If   
      
      Me.filename = filename
      Dim txt As String = String.Empty
      Using sr As New StreamReader(filename)
         txt = sr.ReadToEnd()
      End Using
      nWords = Regex.Matches(txt, pattern).Count
   End Sub
   
   Public ReadOnly Property FullName As String
      Get
         Return filename
      End Get   
   End Property
   
   Public ReadOnly Property Name As String
      Get
         Return Path.GetFileName(filename)
      End Get   
   End Property
   
   Public ReadOnly Property Count As Integer
      Get
         Return nWords
      End Get
   End Property
End Class

Die using -Anweisung ist eigentlich eine syntaktische Möglichkeit.The using statement is actually a syntactic convenience. Zum Zeitpunkt der Kompilierung implementiert der sprach Compiler die Intermediate Language (IL) für try einen / finally -Block.At compile time, the language compiler implements the intermediate language (IL) for a try/finally block.

Weitere Informationen using zur-Anweisung finden Sie in den Themen using-Anweisung oder using- Anweisung .For more information about the using statement, see the Using Statement or using Statement topics.

Der try/endlich-BlockThe Try/Finally block

Wenn Ihre Programmiersprache kein Konstrukt using wie die-Anweisung in C# oder Visual Basic unterstützt, oder wenn Sie Sie nicht verwenden möchten, können Sie die IDisposable.Dispose -Implementierung aus dem finally -Block eines try /-Anweisung finally .If your programming language does not support a construct like the using statement in C# or Visual Basic, or if you prefer not to use it, you can call the IDisposable.Dispose implementation from the finally block of a try/finally statement. Im folgenden Beispiel wird der using -Block im vorherigen Beispiel durch einen try / finally -Block ersetzt.The following example replaces the using block in the previous example with a try/finally block.

using System;
using System.IO;
using System.Text.RegularExpressions;

public class WordCount
{
   private String filename = String.Empty;
   private int nWords = 0;
   private String pattern = @"\b\w+\b"; 

   public WordCount(string filename)
   {
      if (! File.Exists(filename))
         throw new FileNotFoundException("The file does not exist.");
      
      this.filename = filename;
      string txt = String.Empty;
      StreamReader sr = null;
      try {
         sr = new StreamReader(filename);
         txt = sr.ReadToEnd();
      }
      finally {
         if (sr != null) sr.Dispose();     
      }
      nWords = Regex.Matches(txt, pattern).Count;
   }
   
   public string FullName
   { get { return filename; } }
   
   public string Name
   { get { return Path.GetFileName(filename); } }
   
   public int Count 
   { get { return nWords; } }
}   
Imports System.IO
Imports System.Text.RegularExpressions

Public Class WordCount
   Private filename As String
   Private nWords As Integer
   Private pattern As String = "\b\w+\b" 

   Public Sub New(filename As String)
      If Not File.Exists(filename) Then
         Throw New FileNotFoundException("The file does not exist.")
      End If   
      
      Me.filename = filename
      Dim txt As String = String.Empty
      Dim sr As StreamReader = Nothing
      Try
         sr = New StreamReader(filename)
         txt = sr.ReadToEnd()
      Finally
         If sr IsNot Nothing Then sr.Dispose() 
      End Try
      nWords = Regex.Matches(txt, pattern).Count
   End Sub
   
   Public ReadOnly Property FullName As String
      Get
         Return filename
      End Get   
   End Property
   
   Public ReadOnly Property Name As String
      Get
         Return Path.GetFileName(filename)
      End Get   
   End Property
   
   Public ReadOnly Property Count As Integer
      Get
         Return nWords
      End Get
   End Property
End Class

Weitere Informationen try / zumMusterfindenSieunterfinally try... Catch... Schließlich Statement, try-endlichoder try-endlich-Anweisung.For more information about the try/finally pattern, see Try...Catch...Finally Statement, try-finally, or try-finally Statement.

Implementieren von IDisposableImplementing IDisposable

Sie sollten nur IDisposable implementieren, wenn Ihr Typ nicht verwaltete Ressourcen direkt verwendet.You should implement IDisposable only if your type uses unmanaged resources directly. Die Consumer ihres Typs können Ihre IDisposable.Dispose -Implementierung aufzurufen, um Ressourcen freizugeben, wenn die Instanz nicht mehr benötigt wird.The consumers of your type can call your IDisposable.Dispose implementation to free resources when the instance is no longer needed. Um Fälle zu behandeln, in denen Sie nicht Disposeaufruft, sollten Sie entweder eine von SafeHandle abgeleitete Klasse verwenden, um die nicht verwalteten Ressourcen zu wrappen, Object.Finalize oder Sie sollten die-Methode für einen Verweistyp überschreiben.To handle cases in which they fail to call Dispose, you should either use a class derived from SafeHandle to wrap the unmanaged resources, or you should override the Object.Finalize method for a reference type. In beiden Fällen verwenden Sie die Dispose -Methode, um die Bereinigung durchzuführen, die nach dem Verwenden der nicht verwalteten Ressourcen erforderlich ist, z. b. das freigeben, freigeben oder Zurücksetzen der nicht verwalteten Ressourcen.In either case, you use the Dispose method to perform whatever cleanup is necessary after using the unmanaged resources, such as freeing, releasing, or resetting the unmanaged resources.

Wichtig

Wenn Sie eine Basisklasse definieren, die nicht verwaltete Ressourcen verwendet und die über Unterklassen verfügen, die verworfen werden sollen, sollten Sie die IDisposable.Dispose -Methode implementieren und eine zweite Überladung von Disposebereitstellen, wie im nächsten Abschnitt erläutert wird. Sektions.If you are defining a base class that uses unmanaged resources and that either has, or is likely to have, subclasses that should be disposed, you should implement the IDisposable.Dispose method and provide a second overload of Dispose, as discussed in the next section.

Iverwerfund die Vererbungs HierarchieIDisposable and the inheritance hierarchy

Eine Basisklasse mit Unterklassen, die gelöscht werden sollten, IDisposable muss wie folgt implementiert werden.A base class with subclasses that should be disposable must implement IDisposable as follows. Sie sollten dieses Muster immer dann verwenden, IDisposable Wenn Sie für einen Typ sealed implementierenNotInheritable , der nicht ist (in Visual Basic).You should use this pattern whenever you implement IDisposable on any type that isn't sealed (NotInheritable in Visual Basic).

  • Es sollte eine öffentliche, nicht virtuelle Dispose() Methode und eine geschützte virtuelle Dispose(Boolean disposing) Methode bereitstellen.It should provide one public, non-virtual Dispose() method and a protected virtual Dispose(Boolean disposing) method.

  • Die Dispose() -Methode muss Dispose(true) aufgerufen werden, um die Leistung zu unterdrücken.The Dispose() method must call Dispose(true) and should suppress finalization for performance.

  • Der Basistyp sollte keine Finalizer enthalten.The base type should not include any finalizers.

Das folgende Code Fragment gibt das Lösch Muster für Basisklassen wieder.The following code fragment reflects the dispose pattern for base classes. Dabei wird davon ausgegangen, dass der Typ die Object.Finalize -Methode nicht überschreibt.It assumes that your type does not override the Object.Finalize method.

using Microsoft.Win32.SafeHandles;
using System;
using System.Runtime.InteropServices;

class BaseClass : IDisposable
{
   // Flag: Has Dispose already been called?
   bool disposed = false;
   // Instantiate a SafeHandle instance.
   SafeHandle handle = new SafeFileHandle(IntPtr.Zero, true);
   
   // Public implementation of Dispose pattern callable by consumers.
   public void Dispose()
   { 
      Dispose(true);
      GC.SuppressFinalize(this);           
   }
   
   // Protected implementation of Dispose pattern.
   protected virtual void Dispose(bool disposing)
   {
      if (disposed)
         return; 
      
      if (disposing) {
         handle.Dispose();
         // Free any other managed objects here.
         //
      }
      
      disposed = true;
   }
}
Imports Microsoft.Win32.SafeHandles
Imports System.Runtime.InteropServices

Class BaseClass : Implements IDisposable
   ' Flag: Has Dispose already been called?
   Dim disposed As Boolean = False
   ' Instantiate a SafeHandle instance.
   Dim handle As SafeHandle = New SafeFileHandle(IntPtr.Zero, True)

   ' Public implementation of Dispose pattern callable by consumers.
   Public Sub Dispose() _
              Implements IDisposable.Dispose
      Dispose(True)
      GC.SuppressFinalize(Me)           
   End Sub
   
   ' Protected implementation of Dispose pattern.
   Protected Overridable Sub Dispose(disposing As Boolean)
      If disposed Then Return
      
      If disposing Then
         handle.Dispose()
         ' Free any other managed objects here.
         '
      End If
      
      disposed = True
   End Sub
End Class

Wenn Sie die Object.Finalize -Methode überschreiben, sollte die-Klasse das folgende Muster implementieren.If you do override the Object.Finalize method, your class should implement the following pattern.

using System;

class BaseClass : IDisposable
{
   // Flag: Has Dispose already been called?
   bool disposed = false;
   
   // Public implementation of Dispose pattern callable by consumers.
   public void Dispose()
   { 
      Dispose(true);
      GC.SuppressFinalize(this);           
   }
   
   // Protected implementation of Dispose pattern.
   protected virtual void Dispose(bool disposing)
   {
      if (disposed)
         return; 
      
      if (disposing) {
         // Free any other managed objects here.
         //
      }
      
      // Free any unmanaged objects here.
      //
      disposed = true;
   }

   ~BaseClass()
   {
      Dispose(false);
   }
}
Class BaseClass : Implements IDisposable
   ' Flag: Has Dispose already been called?
   Dim disposed As Boolean = False
   
   ' Public implementation of Dispose pattern callable by consumers.
   Public Sub Dispose() _
              Implements IDisposable.Dispose
      Dispose(True)
      GC.SuppressFinalize(Me)           
   End Sub
   
   ' Protected implementation of Dispose pattern.
   Protected Overridable Sub Dispose(disposing As Boolean)
      If disposed Then Return
      
      If disposing Then
         ' Free any other managed objects here.
         '
      End If
      
      ' Free any unmanaged objects here.
      '
      disposed = True
   End Sub

   Protected Overrides Sub Finalize()
      Dispose(False)      
   End Sub
End Class

Unterklassen sollten das verwerfbare Muster wie folgt implementieren:Subclasses should implement the disposable pattern as follows:

  • Sie müssen Dispose(Boolean) überschreiben und die Basisklassen-Dispose(Boolean)-Implementierung aufrufen.They must override Dispose(Boolean) and call the base class Dispose(Boolean) implementation.

  • Sie können bei Bedarf einen Finalizer bereitstellen.They can provide a finalizer if needed. Der Finalizer muss Dispose(false) aufrufen.The finalizer must call Dispose(false).

Beachten Sie, dass abgeleitete Klassen die IDisposable -Schnittstelle nicht selbst implementieren und keine Parameter lose Dispose -Methode enthalten.Note that derived classes do not themselves implement the IDisposable interface and do not include a parameterless Dispose method. Sie überschreiben lediglich die Basis Dispose(Boolean) Klassenmethode.They only override the base class Dispose(Boolean) method.

Das folgende Code Fragment reflektiert das Lösch Muster für abgeleitete Klassen.The following code fragment reflects the dispose pattern for derived classes. Dabei wird davon ausgegangen, dass der Typ die Object.Finalize -Methode nicht überschreibt.It assumes that your type does not override the Object.Finalize method.

using Microsoft.Win32.SafeHandles;
using System;
using System.Runtime.InteropServices;

class DerivedClass : BaseClass
{
   // Flag: Has Dispose already been called?
   bool disposed = false;
   // Instantiate a SafeHandle instance.
   SafeHandle handle = new SafeFileHandle(IntPtr.Zero, true);

   // Protected implementation of Dispose pattern.
   protected override void Dispose(bool disposing)
   {
      if (disposed)
         return; 
      
      if (disposing) {
         handle.Dispose();
         // Free any other managed objects here.
         //
      }
      
      // Free any unmanaged objects here.
      //

      disposed = true;
      // Call base class implementation.
      base.Dispose(disposing);
   }
}
Imports Microsoft.Win32.SafeHandles
Imports System.Runtime.InteropServices

Class DerivedClass : Inherits BaseClass 
   ' Flag: Has Dispose already been called?
   Dim disposed As Boolean = False
   ' Instantiate a SafeHandle instance.
   Dim handle As SafeHandle = New SafeFileHandle(IntPtr.Zero, True)

   ' Protected implementation of Dispose pattern.
   Protected Overrides Sub Dispose(disposing As Boolean)
      If disposed Then Return
      
      If disposing Then
         handle.Dispose()
         ' Free any other managed objects here.
         '
      End If
      
      ' Free any unmanaged objects here.
      '
      disposed = True
      
      ' Call base class implementation.
      MyBase.Dispose(disposing)
   End Sub
End Class

Methoden

Dispose()

Führt anwendungsspezifische Aufgaben durch, die mit der Freigabe, der Zurückgabe oder dem Zurücksetzen von nicht verwalteten Ressourcen zusammenhängen.Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

Gilt für:

Siehe auch