IDisposable Arabirim
Tanım
Önemli
Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.
Yönetilmeyen kaynakları serbest bırakmak için bir mekanizma sağlar.
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- Türetilmiş
- Öznitelikler
Örnekler
Aşağıdaki örnekte, arabirimini uygulayan bir kaynak sınıfının nasıl oluşturulacağı gösterilmektedir IDisposable .
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
Açıklamalar
Arabirim IDisposable esas olarak yönetilmeyen kaynakları serbest bırakmak için kullanılır. Atık toplayıcı, bu nesne artık kullanılmadığında yönetilen bir nesneye ayrılan belleği otomatik olarak serbest bırakır. Ancak, çöp toplamanın ne zaman gerçekleşeceğini tahmin etmek mümkün değildir. Ayrıca, çöp toplayıcının pencere tanıtıcıları veya açık dosyalar ve akışlar gibi yönetilmeyen kaynaklar hakkında bilgisi yoktur.
Dispose Yönetilmeyen kaynakları çöp toplayıcıyla birlikte açıkça serbest bırakmak amacıyla bu arabirimin yöntemini kullanın. Bir nesnenin tüketicisi, nesne artık gerekli olmadığında bu yöntemi çağırabilir.
Warning
Arabirimi IDisposable var olan bir sınıfa eklemek uyumsuzluk yaratan bir değişikliktir. Türünüzün mevcut kullanıcıları Dispose'yi çağıramayacağından, türünüz tarafından tutulan yönetilmeyen kaynakların serbest bırakılacağından emin olamazsınız.
IDisposable.Dispose uygulaması, bir örneğin sahip olduğu kaynaklara artık ihtiyaç duyulmadığında bir türün tüketicisi tarafından çağrıldığından, yönetilen nesneyi bir SafeHandle içinde sarmanız (önerilen alternatif) gerekir veya tüketicinin Object.Finalize çağrısını unutması durumunda yönetilmeyen kaynakları serbest bırakmak için Dispose öğesini geçersiz kılmanız gerekir.
Bu arabirimin ve yöntemin Object.Finalize nasıl kullanıldığı hakkında ayrıntılı bir tartışma için Çöp Toplama ve Atma Yöntemi Uygulama konularına bakın.
IDisposable uygulayan bir nesne kullanma
Uygulamanız yalnızca arabirimi uygulayan IDisposable bir nesne kullanıyorsa, kullanmayı bitirdiğinizde nesnenin IDisposable.Dispose uygulamasını çağırmanız gerekir. Programlama dilinize bağlı olarak, bunu iki yoldan biriyle yapabilirsiniz:
- C# ve Visual Basic'teki
usingdeyimi ile F# dilindekiusedeyimi veyausingişlevi gibi bir dil yapısı kullanarak. -
IDisposable.Dispose uygulamasına çağrıyı bir
try/finallyblok içinde sarmalayarak.
Note
Uygulanmış IDisposable türlerin belgelerinde, bu duruma dikkat çekilir ve Dispose uygulamasının çağrılması hatırlatılır.
C#, F# ve Visual Basic Using deyimi
Diliniz C# dilinde using deyimi, Visual Basic'te Using deyimi veya F# dilindeki use deyimi gibi bir yapıyı destekliyorsa, kendinizi açıkça çağırmak IDisposable.Dispose yerine bunu kullanabilirsiniz. Aşağıdaki örnek, bir dosya hakkındaki bilgileri ve içindeki sözcük sayısını koruyan bir WordCount sınıf tanımlarken bu yaklaşımı kullanır.
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
using deyimi (use F# dilinde ifade) aslında söz dizimsel bir kolaylıktır. Derleme zamanında, dil derleyicisi bir try/finally blok için ara dili (IL) uygular.
Deyimi hakkında using daha fazla bilgi için Deyimi Kullanma veya Deyimi kullanma konularına bakın.
Try/Finally bloğu
Programlama diliniz C# veya Visual Basic'teki using deyimi ya da F#'taki use deyimi gibi bir yapıyı desteklemiyorsa veya bunu kullanmak istemiyorsanız, IDisposable.Disposefinallytry deyiminin / bloğundan finally uygulamasını çağırabilirsiniz. Aşağıdaki örnek, önceki örnekteki using bloğu bir try/finally blokla değiştirir.
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
Daha fazla bilgi için try/finally deseni hakkında, Try...Catch...Finally Deyimi, try-finally, try...finally İfadesi veya try-finally Deyimi bölümüne bakın.
IDisposable'ı Uygula
Türünüz yönetilmeyen kaynakları doğrudan kullanıyorsa veya tek kullanımlık kaynakları kendiniz kullanmak istiyorsanız uygulamanız IDisposable gerekir. Türünüzün tüketicileri, örnek artık gerekli olmadığında kaynakları serbest bırakmak için IDisposable.Dispose uygulamanızı çağırabilir. Bunu çağırmayı Dispose başaramadıkları durumları ele almak için, yönetilmeyen kaynakları sarmak amacıyla SafeHandle'den türetilmiş bir sınıf kullanmalı veya bir başvuru türü için Object.Finalize yöntemini geçersiz kılmalısınız. Her iki durumda da, yönetilmeyen kaynakları kullandıktan sonra yönetilmeyen kaynakları serbest bırakma, bırakma veya sıfırlama gibi gerekli temizleme işlemlerini gerçekleştirmek için Dispose yöntemini kullanırsınız. Daha fazla bilgi için IDisposable.Dispose uygulaması bkz Dispose(bool) yöntemini aşırı yükleme.
Important
Yönetilmeyen kaynaklar kullanan ve ya alt sınıflara sahip olan, ya da olması muhtemel bir temel sınıf tanımlıyorsanız, IDisposable.Dispose metodunu uygulamalı ve bir sonraki bölümde açıklandığı gibi Dispose için ikinci bir aşırı yükleme sağlamalısınız.
IDisposable ve devralma hiyerarşisi
Atılabilir olması gereken alt sınıflara sahip bir temel sınıf aşağıdaki gibi uygulanmalıdır IDisposable . Herhangi bir türü IDisposable (Visual Basic'te sealed) değil de NotInheritable ile uyguladığınızda, bu deseni kullanmanız gerekir.
- Tek bir genel, sanal Dispose() olmayan yöntem ve korumalı bir sanal
Dispose(Boolean disposing)yöntem sağlamalıdır. -
Dispose() yöntemi
Dispose(true)çağırmalı ve performans için sonlandırmayı bastırmalıdır. - Temel tür herhangi bir sonlandırıcı içermemelidir.
Aşağıdaki kod parçası temel sınıflar için dispose desenini yansıtır. Türünüzün Object.Finalize yöntemini geçersiz kılmadığını varsayar.
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
Eğer Object.Finalize yöntemini geçersiz kılarsanız, sınıfınız aşağıdaki deseni uygulamalıdır.
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
Alt sınıflar, yok edilebilir deseni şu şekilde uygulamalıdır:
- Öncelikle
Dispose(Boolean), ardından temel sınıfDispose(Boolean)uygulamasını çağırmalıdır. - Gerekirse bir sonlandırıcı sağlayabilirler. Sonlandırıcı
Dispose(false)çağırmalıdır.
Türetilmiş sınıfların kendilerinin IDisposable arabirimi uygulamadığını ve parametresiz Dispose bir yöntem içermediğini unutmayın. Yalnızca temel sınıf Dispose(Boolean) yöntemini geçersiz kılar.
Aşağıdaki kod parçası türetilmiş sınıflar için dispose desenini yansıtır. Türünüzün Object.Finalize yöntemini geçersiz kılmadığını varsayar.
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
Yöntemler
| Name | Description |
|---|---|
| Dispose() |
Yönetilmeyen kaynakları serbest bırakma, serbest bırakma veya sıfırlama ile ilişkili uygulama tanımlı görevleri gerçekleştirir. |
