System.IDisposable felület
Ez a cikk kiegészítő megjegyzéseket tartalmaz az API referenciadokumentációjához.
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.
Figyelmeztetés
Ez egy kompatibilitástörő változás, ha hozzáadja a IDisposable felületet egy meglévő osztályhoz. Mivel a típus korábbi felhasználói nem hívhatók Dispose, nem lehet biztos abban, hogy a típus által birtokolt nem felügyelt erőforrások ki lesznek adva.
Mivel az IDisposable.Dispose implementációt egy adott típusú felhasználó hívja meg, amikor a példány tulajdonában lévő erőforrásokra már nincs szükség, a felügyelt objektumot SafeHandle egy (az ajánlott alternatíva) sorba kell burkolnia, vagy felül kell bírálnia Object.Finalize a nem felügyelt erőforrások felszabadítását abban az esetben, ha a fogyasztó elfelejt meghívni Dispose.
Fontos
.NET-keretrendszer a C++ fordító támogatja az erőforrások determinisztikus ártalmatlanítását, és nem teszi lehetővé a módszer közvetlen megvalósításátDispose.
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:
- Olyan nyelvi szerkezettel, mint a C# és a
using
Visual Basic utasítása, valamint azuse
F# utasítása vagyusing
függvénye. - Ha egy blokkba
try
/finally
csomagolja a IDisposable.Dispose megvalósításra irányuló hívást.
Feljegyzés
A megvalósító IDisposable típusok dokumentációja megjegyzi ezt a tényt, és emlékeztetőt is tartalmaz a megvalósítás meghívásához Dispose .
A C#, F# és Visual Basic Using utasítás
Ha a nyelv támogatja az olyan szerkezeteket, mint a C#-beli használati utasítás, a Visual BasicBen a Using utasítás vagy az F# használati utasítása, használhatja azt ahelyett, hogy kifejezetten meghívja IDisposable.Dispose magát. 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 egy/finally
try
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 : Kipróbálás... Fogás... Végül nyilatkozat, try-finally, try... végül Kifejezés, vagy try-finally utasítás.
IDisposable implementálása
Implementálnia IDisposable kell, ha a típus közvetlenül nem felügyelt erőforrásokat használ, vagy ha saját maga szeretné használni az eldobható erőforrásokat. Az Ön típusának felhasználói meghívhatják az implementációt IDisposable.Dispose az erőforrások felszabadítására, ha a példányra már nincs szükség. 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.
Fontos
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 Dispose
kell 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 tiltania a véglegesítést a teljesítmény szempontjából. - Az alaptípus nem tartalmazhat véglegesítőket.
Az alábbi kódrészlet az alaposztályok elidegenítési mintáját tükrözi. Feltételezi, hogy a típus nem bírálja felül a metódust Object.Finalize .
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ó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 metódust Object.Finalize .
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