IDisposable Interfész
Definíció
Fontos
Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.
Mechanizmust biztosít a nem felügyelt erőforrások kiadásához.
public interface class IDisposablepublic interface IDisposable[System.Runtime.InteropServices.ComVisible(true)]
public interface IDisposabletype IDisposable = interface[<System.Runtime.InteropServices.ComVisible(true)>]
type IDisposable = interfacePublic Interface IDisposable- Származtatott
- Attribútumok
Példák
Az alábbi példa bemutatja, hogyan hozhat létre egy erőforrásosztályt, amely megvalósítja a IDisposable felületet.
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
Megjegyzések
A felület elsődleges használata a IDisposable nem felügyelt erőforrások felszabadítása. A szemétgyűjtő automatikusan felszabadítja a felügyelt objektum számára lefoglalt memóriát, ha az objektum már nincs használatban. A szemétgyűjtés időpontjának előrejelzése azonban nem lehetséges. Ezenkívül a szemétgyűjtő nem ismeri a nem felügyelt erőforrásokat, például az ablakkezelőket, illetve a fájlok és streamek megnyitását.
Ennek a felületnek a Dispose metódusával explicit módon szabadíthat fel nem felügyelt erőforrásokat a szemétgyűjtővel együtt. Az objektum felhasználója akkor hívhatja ezt a metódust, ha már nincs rá szükség.
Warning
Ez egy kompatibilitástörő változás, ha hozzáadja a IDisposable felületet egy meglévő osztályhoz. Mert a típus korábbi felhasználói nem hívják meg Dispose-t, nem lehet biztos abban, hogy a típus által birtokolt nem felügyelt erőforrások felszabadulnak.
Mivel az IDisposable.Dispose implementációt a típus felhasználója hívja meg, amikor a példány tulajdonában lévő erőforrásokra már nincs szükség, javasolt, hogy a felügyelt objektumot burkolja be egy SafeHandle-be (az ajánlott alternatíva), vagy írja felül Object.Finalize-t a nem felügyelt erőforrások felszabadításához arra az esetre, ha a fogyasztó elfelejti meghívni a Dispose-t.
A felület és a Object.Finalize metódus használatáról részletes ismertetést a Szemétgyűjtés és az Ártalmatlanítási módszer implementálása témakörökben talál.
Az IDisposable-t megvalósító objektum használata
Ha az alkalmazás egyszerűen egy olyan objektumot használ, amely implementálja az IDisposable interfészt, akkor a használat befejezésekor meg kell hívnia az objektum implementációját IDisposable.Dispose . A programozási nyelvtől függően ezt kétféleképpen teheti meg:
- Nyelvi szerkezetek használatával, mint amilyen a
usingutasítás C#-ban és Visual Basic-ben, valamint azuseutasítás vagy ausingfüggvény F#-ban. - A IDisposable.Dispose
try/ blokkba csomagolva afinallymegvalósításra irányuló hívást.
Megjegyzés:
Azoknak a típusoknak a dokumentációja, amelyek megvalósítják a IDisposable, megjegyzi ezt a tényt, és tartalmaz egy emlékeztetőt a Dispose megvalósításának meghívására.
A C#, F# és Visual Basic Using utasítás
Ha a nyelv támogatja az olyan szerkezeteket, mint a C#-beli using utasítás, a Visual Basic-beli Using utasítás vagy az F#-beli use utasítás, akkor használhatja, ahelyett hogy magát IDisposable.Dispose hívná meg közvetlenül. Az alábbi példa ezt a megközelítést használja egy WordCount olyan osztály definiálásához, amely megőrzi egy fájl adatait és a benne lévő szavak számát.
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; } }
}
open System.IO
open System.Text.RegularExpressions
type WordCount(filename) =
let txt =
if File.Exists filename |> not then
raise (FileNotFoundException "The file does not exist.")
use sr = new StreamReader(filename)
sr.ReadToEnd()
let pattern = @"\b\w+\b"
let nWords = Regex.Matches(txt, pattern).Count
member _.FullName = filename
member _.Name = Path.GetFileName filename
member _.Count = 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
Az using utasítás (use kifejezés F#-ban) valójában szintaktikai kényelem. Fordításkor a nyelvi fordító implementálja a blokkok köztes nyelvét try/finally (IL).
Az utasítással kapcsolatos további információkért using tekintse meg az Utasítás használata vagy az Utasítás használata témakört.
A Kipróbálás/Végül blokk
Ha a programozási nyelv nem támogatja az olyan szerkezeteket, mint a C# vagy a using Visual Basic utasítása, vagy az use F# utasítás, vagy ha nem szeretné használni, meghívhatja az IDisposable.Dispose implementációt egyfinallytry/finally utasításblokkból. Az alábbi példa az using előző példában szereplő blokkot egy try/finally blokkra cseréli.
using System;
using System.IO;
using System.Text.RegularExpressions;
public class WordCount2
{
private String filename = String.Empty;
private int nWords = 0;
private String pattern = @"\b\w+\b";
public WordCount2(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; } }
}
open System.IO
open System.Text.RegularExpressions
type WordCount2(filename) =
let txt =
if File.Exists filename |> not then
raise (FileNotFoundException "The file does not exist.")
let sr = new StreamReader(filename)
try
sr.ReadToEnd()
finally
sr.Dispose()
let pattern = @"\b\w+\b"
let nWords = Regex.Matches(txt, pattern).Count
member _.FullName = filename
member _.Name = Path.GetFileName filename
member _.Count = nWords
Imports System.IO
Imports System.Text.RegularExpressions
Public Class WordCount2
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
A mintával kapcsolatos további információkért try/finally lásd Try...Catch...Finally utasítás, try-finally, try...finally kifejezés, vagy try-finally utasítás.
IDisposable implementálása
A IDisposable-t kell implementálnia, ha a típus közvetlenül nem kezelt erőforrásokat használ, vagy ha önmaga szeretné használni az eldobható erőforrásokat. Az Ön típusához tartozó felhasználók meghívhatják a IDisposable.Dispose implementációt az erőforrások felszabadítására, amikor már nincs szükség az adott példányra. Ha olyan eseteket szeretne kezelni, amelyekben nem sikerül meghívni Disposeőket, használjon egy, a nem felügyelt erőforrások burkolásához származtatott SafeHandle osztályt, vagy felül kell bírálnia egy Object.Finalize referenciatípus metódusát. Mindkét esetben a Dispose nem felügyelt erőforrások ( például a nem felügyelt erőforrások felszabadítása, felszabadítása vagy alaphelyzetbe állítása) használata után bármilyen szükséges tisztítást végrehajthat. A megvalósítással IDisposable.Disposekapcsolatos további információkért lásd az Dispose(bool) metódus túlterhelését.
Important
Ha olyan alaposztályt határoz meg, amely nem felügyelt erőforrásokat használ, és amelyek vagy rendelkeznek vagy valószínűleg rendelkeznek olyan alosztályokkal, amelyeket el kell helyezni, akkor implementálnia kell a IDisposable.Dispose metódust, és a következő szakaszban ismertetett második túlterhelést Disposekell biztosítania.
Az IDisposable és az öröklési hierarchia
Az eldobható alosztályokkal rendelkező alaposztálynak az alábbiak szerint kell implementálnia IDisposable . Ezt a mintát akkor érdemes használnia, ha olyan típust implementál IDisposable , amely nem sealed (NotInheritable a Visual Basicben).
- Egy nyilvános, nem virtuális Dispose() metódust és egy védett virtuális
Dispose(Boolean disposing)módszert kell biztosítania. - A Dispose() metódusnak meg kell hívnia
Dispose(true), és el kell nyomnia a véglegesítést a teljesítmény javítása érdekében. - Az alaptípus nem tartalmazhat véglegesítőket.
Az alábbi kódrészlet az alaposztályok elvetési mintát tükrözi. Feltételezi, hogy a típus nem bírálja felül a Object.Finalize metódust.
using System;
using System.IO;
using System.Runtime.InteropServices;
class BaseClass1 : IDisposable
{
// Flag: Has Dispose already been called?
bool disposed = false;
// Instantiate a FileStream instance.
FileStream fs = new FileStream("test.txt", FileMode.OpenOrCreate);
// Public implementation of Dispose pattern callable by consumers.
public void Dispose()
{
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
// Protected implementation of Dispose pattern.
protected virtual void Dispose(bool disposing)
{
if (disposed)
return;
if (disposing)
{
fs.Dispose();
// Free any other managed objects here.
//
}
disposed = true;
}
}
open System
open System.IO
type BaseClass1() =
// Flag: Has Dispose already been called?
let mutable disposed = false
// Instantiate a FileStream instance.
let fs = new FileStream("test.txt", FileMode.OpenOrCreate)
interface IDisposable with
// Public implementation of Dispose pattern callable by consumers.
member this.Dispose() =
this.Dispose true
GC.SuppressFinalize this
// Implementation of Dispose pattern.
abstract Dispose: bool -> unit
override _.Dispose(disposing) =
if not disposed then
if disposing then
fs.Dispose()
// Free any other managed objects here.
disposed <- true
Imports System.IO
Imports System.Runtime.InteropServices
Class BaseClass1 : Implements IDisposable
' Flag: Has Dispose already been called?
Dim disposed As Boolean = False
' Instantiate a FileStream instance.
Dim fs As FileStream = New FileStream("test.txt", FileMode.OpenOrCreate)
' Public implementation of Dispose pattern callable by consumers.
Public Sub Dispose() _
Implements IDisposable.Dispose
Dispose(disposing:=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
fs.Dispose()
' Free any other managed objects here.
'
End If
disposed = True
End Sub
End Class
Ha felülírja a metódust Object.Finalize , az osztálynak az alábbi mintát kell implementálnia.
using System;
class BaseClass2 : IDisposable
{
// Flag: Has Dispose already been called?
bool disposed = false;
// Public implementation of Dispose pattern callable by consumers.
public void Dispose()
{
Dispose(disposing: 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;
}
~BaseClass2()
{
Dispose(disposing: false);
}
}
open System
type BaseClass2() =
// Flag: Has Dispose already been called?
let mutable disposed = false
interface IDisposable with
// Public implementation of Dispose pattern callable by consumers.
member this.Dispose() =
this.Dispose true
GC.SuppressFinalize this
// Implementation of Dispose pattern.
abstract Dispose: bool -> unit
override _.Dispose(disposing) =
if not disposed then
if disposing then
// Free any other managed objects here.
()
// Free any unmanaged objects here.
disposed <- true
override this.Finalize() =
this.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(disposing:=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(disposing:=False)
End Sub
End Class
Az alosztályoknak az alábbiak szerint kell megvalósítaniuk az eldobható mintát:
- Felül kell bírálniuk
Dispose(Boolean), és meg kell hívniuk az alaposztályDispose(Boolean)implementációját. - Szükség esetén finalizert is biztosíthatnak. A véglegesítőnek meg kell hívnia
Dispose(false).
Vegye figyelembe, hogy a származtatott osztályok maguk nem implementálják az IDisposable interfészt, és nem tartalmaznak paraméter nélküli Dispose metódust. Csak az alaposztály Dispose(Boolean) metódusát bírálják felül.
A következő kódrészlet a származtatott osztályok elidegenítési mintáját tükrözi. Feltételezi, hogy a típus nem bírálja felül a Object.Finalize metódust.
using System;
using System.IO;
using System.Runtime.InteropServices;
class MyDerivedClass : MyBaseClass
{
// Flag: Has Dispose already been called?
bool disposed = false;
// Instantiate a FileStream instance.
FileStream fs = new FileStream("test.txt", FileMode.OpenOrCreate);
// Protected implementation of Dispose pattern.
protected override void Dispose(bool disposing)
{
if (disposed)
return;
if (disposing)
{
fs.Dispose();
// Free any other managed objects here.
//
}
// Free any unmanaged objects here.
//
disposed = true;
// Call base class implementation.
base.Dispose(disposing);
}
}
open Microsoft.Win32.SafeHandles
open System
type MyDerivedClass() =
inherit MyBaseClass()
// Flag: Has Dispose already been called?
let mutable disposed = false
// Instantiate a FileStream instance.
let fs = new FileStream("test.txt", FileMode.OpenOrCreate)
// Implementation of Dispose pattern.
override _.Dispose(disposing) =
if not disposed then
if disposing then
fs.Dispose()
// Free any other managed objects here.
// Free any unmanaged objects here.
disposed <- true
// Call base class implementation.
base.Dispose disposing
Imports System.IO
Imports System.Runtime.InteropServices
Class DerivedClass2 : Inherits BaseClass2
' Flag: Has Dispose already been called?
Dim disposed As Boolean = False
' Instantiate a FileStream instance.
Dim fs As FileStream = New FileStream("test.txt", FileMode.OpenOrCreate)
' Protected implementation of Dispose pattern.
Protected Overrides Sub Dispose(disposing As Boolean)
If disposed Then Return
If disposing Then
fs.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
Metódusok
| Name | Description |
|---|---|
| Dispose() |
Végrehajtja a nem felügyelt erőforrások felszabadításával, felszabadításával vagy alaphelyzetbe állításával kapcsolatos alkalmazásalapú feladatokat. |
