System.IDisposable arabirimi

Bu makale, bu API'nin başvuru belgelerine ek açıklamalar sağlar.

Arabirimin IDisposable birincil kullanımı yönetilmeyen kaynakları serbest bırakmaktı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ı atık toplayıcıyla birlikte açıkça serbest bırakmak için bu arabirimin yöntemini kullanın. Bir nesnenin tüketicisi, nesne artık gerekli olmadığında bu yöntemi çağırabilir.

Uyarı

Arabirimi var olan bir sınıfa eklemek IDisposable hataya neden olan bir değişikliktir. Türünüzün önceden var olan tüketicileri öğesini çağıramadığından Dispose, türünüz tarafından tutulan yönetilmeyen kaynakların serbest bırakılacağından emin olamazsınız.

IDisposable.Dispose Bir örneğin sahip olduğu kaynaklara artık ihtiyaç duyulmadığında uygulama bir türün tüketicisi tarafından çağrıldığından, yönetilen nesneyi bir SafeHandle içinde sarmalamanız (önerilen alternatif) veya tüketicinin çağırmayı Disposeunutması durumunda yönetilmeyen kaynakları serbest bırakmanız gerekirObject.Finalize.

Önemli

.NET Framework'te, C++ derleyicisi kaynakların belirlenimici bir şekilde yok edilmesini destekler ve yöntemin doğrudan uygulanmasına Dispose izin vermez.

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 içindeki deyimi ve F# dilinde deyimi use veya using işlevi gibi using bir dil yapısı kullanarak.
• Uygulamaya çağrıyı IDisposable.Dispose bir try/finally blok halinde sarmalayarak.

Not

Bunu uygulayan IDisposable türlerin belgeleri, bu olguya dikkat edin ve uygulamasını Dispose çağırmak için bir anımsatıcı içerir.

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

deyimi using (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 deyimi veya F# deyimi gibi using bir yapıyı use desteklemiyorsa veya bunu kullanmamak isterseniz, uygulamayı deyimininfinallytry/bloğundan finally çağırabilirsinizIDisposable.Dispose. 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

Desen hakkında try/finally daha fazla bilgi için bkz . Deneyin... Yakalamak... Finally Deyimi, try-finally, try... finally İfadesi veya try-finally Deyimi.

IDisposable Uygulama

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 uygulamanızı serbest kaynaklara çağırabilir IDisposable.Dispose . çağrılamadığı Disposedurumları işlemek için, yönetilmeyen kaynakları sarmak için öğesinden SafeHandle türetilmiş bir sınıf kullanmanız veya bir başvuru türü için yöntemini geçersiz kılmanız Object.Finalize gerekir. Her iki durumda da, yönetilmeyen kaynakları kullandıktan sonra yönetilmeyen kaynakları serbest bırakma, serbest bırakma veya sıfırlama gibi gerekli temizleme işlemlerini gerçekleştirmek için yöntemini kullanırsınız Dispose . uygulaması IDisposable.Disposehakkında daha fazla bilgi için bkz . Dispose(bool) yöntemi aşırı yüklemesi.

Önemli

Yönetilmeyen kaynaklar kullanan ve atılması gereken alt sınıflara sahip veya olması muhtemel bir temel sınıf tanımlıyorsanız, yöntemini uygulamalı IDisposable.Dispose ve sonraki bölümde açıklandığı gibi ikinci bir aşırı yükleme Disposesağ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 . ( Visual Basic'te) olmayan sealedNotInheritable herhangi bir türe uyguladığınızda IDisposable bu düzeni 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 çağırmalıdır Dispose(true) ve performans için sonlandırmayı göstermemelidir.
• 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 yöntemini geçersiz kılmadığını Object.Finalize 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

yöntemini geçersiz kılarsanız Object.Finalize , 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 atılabilir deseni aşağıdaki gibi uygulamalıdır:

• Temel sınıf Dispose(Boolean) uygulamasını geçersiz kılmalı Dispose(Boolean) ve çağırmalıdır.
• Gerekirse bir sonlandırıcı sağlayabilirler. Sonlandırıcı çağırmalıdır Dispose(false).

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 yöntemini geçersiz kılmadığını Object.Finalize 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