Bu makale, makine tarafından çevrilmiştir. Makaleyi İngilizce dilinde görüntülemek için İngilizce onay kutusunu işaretleyin. Ayrıca, fare işaretçisiyle İngilizce metnin üzerine gelerek metni açılır pencerede de görüntüleyebilirsiniz.
Çeviri
İngilizce

IDisposable Arabirimi

 

Yayımlanan: Ağustos 2016

Yönetilmeyen kaynakları serbest bırakmak için bir mekanizma sağlar.

Bu tür için .NET Framework kaynak kodu göz atmak için bkz: Reference Source.

Ad alanı:   System
Derleme:  mscorlib (mscorlib.dll içinde)

[ComVisibleAttribute(true)]
public interface IDisposable

AdıAçıklama
System_CAPS_pubmethodDispose()

Boşaltma, serbest bırakma veya yönetilmeyen kaynakları sıfırlama ile ilişkili uygulama tanımlı görevleri gerçekleştirir.

System_CAPS_noteNot

Bu tür için .NET Framework kaynak kodunu görüntülemek için bkz: Reference Source. Kaynak kodu çevrimiçi göz atın, çevrimdışı izleme başvurusu indirin ve hata ayıklama sırasında (düzeltme eklerini ve güncelleştirmeleri dahil) kaynakları aracılığıyla adım; see instructions.

Birincil bu arabirimin yönetilmeyen kaynakları serbest bırakmak için kullanılır. Çöp toplayıcı otomatik olarak o nesne artık kullanıldığında, yönetilen bir nesne için ayrılan belleği serbest bırakır. Ancak, atık toplama ne zaman yapılacağını tahmin etmek mümkün değildir. Ayrıca, atık toplayıcı pencere işleyicileri gibi yönetilmeyen kaynakları olanağıyla sahip veya dosyalar ve akışlar açın.

Kullanım Dispose açıkça atık toplayıcı ile birlikte yönetilmeyen kaynakları serbest bırakmak için bu arabirimin yöntemi. Nesne artık gerekli olmadığında tüketici bir nesnenin bu yöntemini çağırabilirsiniz.

System_CAPS_warningUyarı

Eklemek için önemli bir değişiklik olduğunu IDisposable varolan bir sınıfa arabirimi. Önceden varolan tüketicileri türünüze çağrılamıyor çünkü Dispose, türü tarafından tutulan yönetilmeyen kaynakları serbest bırakılacak belirli olamaz.

Çünkü IDisposable.Dispose uygulama, bir tür tüketici tarafından çağrıldığında, bir örneği tarafından sahip olunan kaynaklar artık gerekmediğinde, yönetilen nesne ya da kaydırılacağını bir SafeHandle (önerilen seçenek) veya geçersiz kılmalısınız Object.Finalize çağırmak tüketici unutması durumunda, yönetilmeyen kaynakları serbest Dispose.

System_CAPS_importantÖnemli

.NET Framework C++ derleyicisi kaynakların belirleyici bırakma destekler ve doğrudan uyarlamasını izin verme Dispose yöntemi.

Konusunda ayrıntılı bilgi için bu arabirimi ve Object.Finalize yöntemi kullanılıyorsa, bkz: Çöp Toplama ve Dispose Yöntemi Uygulama Konular.

Uygulama IDisposable yalnızca yönetilmeyen kaynakları doğrudan kullanıyorsanız. Uygulamanız yeterlidir uygulayan bir nesne kullanıyorsa IDisposable, sağlamıyorsa bir IDisposable uygulaması. Bunun yerine, nesnenin çağırmalıdır IDisposable.Dispose kullanmadan bittiğinde uygulama. Programlama diliniz bağlı olarak bunu iki yoldan biriyle yapabilirsiniz:

  • Bir dil kullanarak gibi oluşturmak using C# ve Visual Basic deyiminde.

  • Çağrı kaydırma tarafından IDisposable.Dispose uygulamasında bir try/catch bloğu.

System_CAPS_noteNot

Belgelerine türleri uygulayan IDisposable bu olgu not edin ve çağırmak için bir anımsatıcı dahil kendi Dispose uygulaması.

Dilinizi bir yapı gibi destekliyorsa kullanarak deyimi C# ve kullanma deyimi Visual Basic'te kullanabilirsiniz açıkça çağırmak yerine IDisposable.Dispose kendiniz. Aşağıdaki örnek, tanımlamakta bu yaklaşımı kullanır bir WordCount bir dosya ve bu sözcükleri sayısı hakkında bilgiler saklayan sınıf.

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; } }
}   

using Gerçekten söz dizimi kolaylık sağlamak amacıyla bir ifadedir. Derleme zamanında dil derleyicisi için Ara dile (IL) uygulayan bir try/catch bloğu.

Hakkında daha fazla bilgi için using deyimi, bkz: Using Deyimi (Visual Basic) veya using Deyimi (C# Başvurusu) Konular.

Programlama diliniz gibi bir yapı desteklemez, using C# veya Visual Basic deyiminde ya da onu kullanmayı tercih ederseniz, çağırabilirsiniz IDisposable.Dispose uygulamasından finally , engelleme bir try/catch deyimi. Aşağıdaki örnek değiştirir using ile önceki örnekte engelleme bir try/catch/finally bloğu.

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;
      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; } }
}   

Hakkında daha fazla bilgi için try/finally desen bkz Try...Catch...Finally Deyimi (Visual Basic), try-finally (C# Başvurusu), veya try-finally Deyimi (C).

Uygulamanız gerekir IDisposable yalnızca türünüz yönetilmeyen kaynakları doğrudan kullanıyorsa. Türünüz tüketicileri çağırabilir, IDisposable.Dispose örneği artık gerekli olmadığında kaynakları serbest uygulama. Hangi başarısız çağırmak durumlarında Dispose, türetilmiş bir sınıf ya da kullanım gereken SafeHandle yönetilmeyen kaynakları veya sarmalamak için geçersiz kılmalıdır Object.Finalize yöntemi için bir başvuru türü. Her iki durumda da, kullandığınız Dispose boşaltma, serbest bırakma veya yönetilmeyen kaynakları sıfırlama gibi yönetilmeyen kaynakları kullandıktan sonra ne olursa olsun temizleme gereklidir yapmak için yöntemi.

System_CAPS_importantÖnemli

Bir taban sınıf tanımlıyorsanız, yönetilmeyen kaynakları kullanan ve, sahip veya sağlamak, çıkarılması gereken alt sınıfların olasıdır, uygulamanız gerekir IDisposable.Dispose yöntemi ve ikinci bir aşırı yüklemesini sağlayan Dispose, sonraki bölümde açıklandığı gibi.

Atılabilir olmalıdır alt sınıfların temel bir sınıfla uygulamalıdır IDisposable gibi. Uygulamanız olduğunda bu deseni kullanması gereken IDisposable olmayan herhangi bir türü üzerinde sealed (NotInheritable Visual Basic'te).

  • Sanal olmayan bir ortak sağlamalıdır Dispose() yöntemi ve korumalı bir sanal Dispose(Boolean disposing) yöntemi.

  • Dispose() Yöntemi çağırmanız gerekir Dispose(true) ve performans için sonlandırma bastırmak.

  • Temel türün herhangi sonlandırıcılar içermemelidir.

Aşağıdaki kod parçası, temel sınıflar için dispose deseni yansıtır. Türünüz geçersiz varsayar Object.Finalize yöntemi.

using Microsoft.Win32.SafeHandles;
using System;
using System.Runtime.InteropServices;

class BaseClass : IDisposable
{
   // Flag: Has Dispose already been called?
   bool disposed = false;
   // Instantiate a SafeHandle instance.
   SafeHandle handle = new SafeFileHandle(IntPtr.Zero, true);

   // Public implementation of Dispose pattern callable by consumers.
   public void Dispose()
   { 
      Dispose(true);
      GC.SuppressFinalize(this);           
   }

   // Protected implementation of Dispose pattern.
   protected virtual void Dispose(bool disposing)
   {
      if (disposed)
         return; 

      if (disposing) {
         handle.Dispose();
         // Free any other managed objects here.
         //
      }

      // Free any unmanaged objects here.
      //
      disposed = true;
   }
}

Geçersiz kılarsanız Object.Finalize yöntemi, sınıfınıza aşağıdaki düzeni uygulamanız gerekir.

using System;

class BaseClass : IDisposable
{
   // Flag: Has Dispose already been called?
   bool disposed = false;

   // Public implementation of Dispose pattern callable by consumers.
   public void Dispose()
   { 
      Dispose(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;
   }

   ~BaseClass()
   {
      Dispose(false);
   }
}

Alt sınıfların atılabilir düzeni gibi uygulamanız gerekir:

  • Geçersiz kılmalısınız Dispose(Boolean) ve temel sınıfı çağırın Dispose(Boolean) uygulaması.

  • Gerekirse, bir sonlandırıcı sağlayabilir. Sonlandırıcıyı çağırmalısınız Dispose(false).

Türetilen sınıflar kendilerini uygulamayan olduğunu unutmayın IDisposable arabirim ve parametresiz bir içermez Dispose yöntemi. Bunlar yalnızca temel sınıfı geçersiz Dispose(Boolean) yöntemi.

Aşağıdaki kod parçası türetilen sınıflar için dispose deseni yansıtır. Türünüz geçersiz varsayar Object.Finalize yöntemi.

using Microsoft.Win32.SafeHandles;
using System;
using System.Runtime.InteropServices;

class DerivedClass : BaseClass
{
   // Flag: Has Dispose already been called?
   bool disposed = false;
   // Instantiate a SafeHandle instance.
   SafeHandle handle = new SafeFileHandle(IntPtr.Zero, true);

   // Protected implementation of Dispose pattern.
   protected override void Dispose(bool disposing)
   {
      if (disposed)
         return; 

      if (disposing) {
         handle.Dispose();
         // Free any other managed objects here.
         //
      }

      // Free any unmanaged objects here.
      //

      disposed = true;
      // Call base class implementation.
      base.Dispose(disposing);
   }
}

Aşağıdaki örnek, uygulayan bir kaynak sınıfı oluşturmak üzere gösterilmiştir IDisposable arabirimi.

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(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(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# destructor syntax for finalization code.
        // This destructor will run only if the Dispose method
        // does not get called.
        // It gives your base class the opportunity to finalize.
        // Do not provide destructors in types derived from this class.
        ~MyResource()
        {
            // Do not re-create Dispose clean-up code here.
            // Calling Dispose(false) is optimal in terms of
            // readability and maintainability.
            Dispose(false);
        }
    }
    public static void Main()
    {
        // Insert code here to create
        // and use the MyResource object.
    }
}

Evrensel Windows Platformu
8 sonrasında kullanılabilir
.NET Framework
1.1 sonrasında kullanılabilir
Taşınabilir Sınıf Kitaplığı
Destekleyen: taşınabilir .NET platformları
Silverlight
2.0 sonrasında kullanılabilir
Windows Phone Silverlight
7.0 sonrasında kullanılabilir
Windows Phone
8.1 sonrasında kullanılabilir
Başa dön
Show: