IDisposable.Dispose Metod
Definition
Viktigt
En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.
Utför programdefinierade uppgifter som är associerade med att frigöra, frigöra eller återställa ohanterade resurser.
public:
void Dispose();public void Dispose();abstract member Dispose : unit -> unitPublic Sub Dispose ()Exempel
I följande exempel visas hur du kan implementera Dispose metoden.
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(disposing: true);
// This object will be cleaned up by the Dispose method.
// Therefore, you should call GC.SuppressFinalize 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# finalizer syntax for finalization code.
// 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 finalizer in types derived from this class.
~MyResource()
{
// Do not re-create Dispose clean-up code here.
// Calling Dispose(disposing: false) is optimal in terms of
// readability and maintainability.
Dispose(disposing: false);
}
}
public static void Main()
{
// Insert code here to create
// and use the MyResource object.
}
}
// The following example demonstrates how to create
// a resource class that implements the IDisposable interface
// and the IDisposable.Dispose method.
open System
open System.ComponentModel
open System.Runtime.InteropServices
// Use interop to call the method necessary
// to clean up the unmanaged resource.
[<DllImport "Kernel32">]
extern Boolean CloseHandle(nativeint handle)
// A base class that implements IDisposable.
// By implementing IDisposable, you are announcing that
// instances of this type allocate scarce resources.
type MyResource(handle: nativeint) =
// Pointer to an external unmanaged resource.
let mutable handle = handle
// Other managed resource this class uses.
let comp = new Component()
// Track whether Dispose has been called.
let mutable disposed = false
// Implement IDisposable.
// Do not make this method virtual.
// A derived class should not be able to override this method.
interface IDisposable with
member this.Dispose() =
this.Dispose true
// This object will be cleaned up by the Dispose method.
// Therefore, you should call GC.SuppressFinalize 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.
abstract Dispose: bool -> unit
override _.Dispose(disposing) =
// Check to see if Dispose has already been called.
if not disposed then
// If disposing equals true, dispose all managed
// and unmanaged resources.
if disposing then
// Dispose managed resources.
comp.Dispose()
// Call the appropriate methods to clean up
// unmanaged resources here.
// If disposing is false,
// only the following code is executed.
CloseHandle handle |> ignore
handle <- IntPtr.Zero
// Note disposing has been done.
disposed <- true
// 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 finalizer in types derived from this class.
override this.Finalize() =
// Do not re-create Dispose clean-up code here.
// Calling Dispose(disposing: false) is optimal in terms of
// readability and maintainability.
this.Dispose false
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(disposing:=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(disposing:=False) is optimal in terms of
' readability and maintainability.
Dispose(disposing:=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
Kommentarer
Använd den här metoden för att stänga eller frigöra ohanterade resurser, till exempel filer, strömmar och handtag som innehas av en instans av klassen som implementerar det här gränssnittet. Enligt konventionen används den här metoden för alla aktiviteter som är associerade med att frigöra resurser som innehas av ett objekt eller förbereda ett objekt för återanvändning.
Varning
Om du använder en klass som implementerar IDisposable gränssnittet bör du anropa dess Dispose implementering när du är klar med klassen. Mer information finns i avsnittet "Använda ett objekt som implementerar IDisposable" i ämnet IDisposable .
När du implementerar den här metoden ska du se till att alla lagrade resurser frigörs genom att anropet sprids via inneslutningshierarkin. Om ett objekt A till exempel allokerar ett objekt B och objekt B allokerar ett objekt C, måste A:s Dispose implementering anropa Dispose B, vilket i sin tur måste anropa Dispose C.
Important
C++-kompilatorn stöder deterministisk borttagning av resurser och tillåter inte direkt implementering av Dispose metoden.
Ett objekt måste också anropa metoden för Dispose basklassen om basklassen implementerar IDisposable. Mer information om hur du implementerar IDisposable en basklass och dess underklasser finns i avsnittet "IDisposable och arvshierarkin" i ämnet IDisposable .
Om ett objekts Dispose-metod anropas mer än en gång måste objektet ignorera alla anrop efter den första. Objektet får inte utlösa ett undantag om dess Dispose-metod anropas flera gånger. Andra instansmetoder än Dispose kan utlösa en ObjectDisposedException när resurser redan har tagits bort.
Användare kan förvänta sig att en resurstyp använder en viss konvention för att ange ett allokerat tillstånd jämfört med ett frigjort tillstånd. Ett exempel på detta är strömklasser som traditionellt betraktas som öppna eller stängda. Implementeraren för en klass som har en sådan konvention kan välja att implementera en offentlig metod med ett anpassat namn, till exempel , som Closeanropar Dispose metoden.
Dispose Eftersom metoden måste anropas explicit finns det alltid en risk att de ohanterade resurserna inte släpps, eftersom användaren av ett objekt inte anropar dess Dispose metod. Det finns två sätt att undvika detta:
Omslut den hanterade resursen i ett objekt som härletts från System.Runtime.InteropServices.SafeHandle. Implementeringen Dispose anropar Dispose sedan metoden för System.Runtime.InteropServices.SafeHandle instanserna. Mer information finns i avsnittet "Alternativet SafeHandle" i ämnet Object.Finalize .
Implementera en finalizer för att frigöra resurser när Dispose den inte anropas. Som standard anropar skräpinsamlaren automatiskt ett objekts slutförare innan dess minne frigörs. Men om Dispose metoden har anropats är det vanligtvis onödigt för skräpinsamlaren att anropa slutföraren för det borttagna objektet. För att förhindra automatisk slutförande Dispose kan implementeringar anropa GC.SuppressFinalize metoden.
När du använder ett objekt som har åtkomst till ohanterade resurser, till exempel en StreamWriter, är det bra att skapa instansen med en using -instruktion. Instruktionen using stänger automatiskt strömmen och anropar Dispose objektet när koden som använder den har slutförts. Ett exempel finns i StreamWriter klassen .
