Çöp Toplayıcı IDisposable'ı arayacak mı?

.NET IDisposable Pattern , bir sonlandırıcı yazar ve IDisposable uygularsanız sonlandırıcının açıkça Dispose'i çağırması gerektiğini belirtir. Bu mantıklı ve sonlandırıcının garanti edildiği nadir durumlarda her zaman yaptığım şey bu.

Ancak, sadece bunu yaparsam ne olur:

class Foo : IDisposable
{
     public void Dispose(){ CloseSomeHandle(); }
}

ve bir sonlandırıcı veya başka bir şey uygulamayın. Çerçeve benim için Dispose yöntemini çağıracak mı?

Evet, bunun kulağa aptalca geldiğini anlıyorum ve tüm mantık olmayacağını ima ediyor, ama kafamın arkasında her zaman beni emin kılan 2 şey vardı.

1. Birkaç yıl önce birileri bir keresinde bunun gerçekten yapacağını söyledi ve bu kişi "eşyalarını bilme" konusunda çok sağlam bir sicile sahipti.

2. Derleyici / çerçeve, hangi arabirimleri uyguladığınıza bağlı olarak diğer 'sihirli' şeyler yapar (ör: foreach, genişletme yöntemleri, niteliklere dayalı serileştirme, vb.), Bu da bunun 'sihir' olabileceği mantıklıdır.

Bununla ilgili birçok şey okurken ve ima edilen birçok şey olsa da, bu soruya kesin bir Evet veya Hayır yanıtı bulamadım .

Net Çöp Toplayıcı, çöp toplamadaki bir nesnenin Object.Finalize yöntemini çağırır. By varsayılan bunu yapar şey ve ek kaynak boşaltmak isterseniz overidden olmalıdır.

Bertaraf otomatik olarak adlandırılır DEĞİLDİR ve olmalıdır explicity böyle bir 'nihayet denemek' 'kullanarak' ya da blok içerisindeki olarak kaynaklarını serbest bırakılması halinde denir,

daha fazla bilgi için http://msdn.microsoft.com/tr-tr/library/system.object.finalize.aspx adresine bakın.

Yorumunda Brian'ın amacını vurgulamak istiyorum, çünkü önemli.

Finalizörler C ++ gibi deterministik yıkıcılar değildir. Diğerleri işaret gibi, adı verilecek ne zaman garantisi yoktur ve siz, yeterli bellek varsa gerçekten o eğer hiç çağrılabilir.

Ancak finalizörlerin kötü yanı, Brian'ın dediği gibi, nesnenizin bir çöp koleksiyonunda hayatta kalmasına neden olmasıdır. Bu kötü olabilir. Neden?

Bildiğiniz veya bilmediğiniz gibi, GC nesillere bölünür - Gen 0, 1 ve 2 artı Büyük Nesne Yığını. Bölme gevşek bir terimdir - bir bellek bloğu alırsınız, ancak Gen 0 nesnelerinin başladığı ve bittiği işaretçiler vardır.

Düşünce süreci, kısa ömürlü olacak çok sayıda nesne kullanmanızdır. Yani bunlar GC'nin Gen 0 nesnelerine ulaşması için kolay ve hızlı olmalıdır. Bellek baskısı olduğunda, yaptığı ilk şey Gen 0 koleksiyonudur.

Şimdi, bu yeterli basıncı çözmezse, o zaman geri döner ve bir Gen 1 taraması yapar (Gen 0'ı yineleme) ve sonra hala yeterli değilse, Gen 2 taraması yapar (Gen 1 ve Gen 0'ı yineleme). Bu nedenle uzun ömürlü nesneleri temizlemek biraz zaman alabilir ve oldukça pahalı olabilir (çünkü iplikleriniz işlem sırasında askıya alınabilir).

Bu, eğer böyle bir şey yaparsanız:

~MyClass() { }

Nesneniz, ne olursa olsun, 2. Nesil'de yaşayacak. Bunun nedeni, GC'nin çöp toplama sırasında sonlandırıcıyı çağırmanın bir yolu olmamasıdır. Böylece sonlandırılması gereken nesneler, farklı bir iş parçacığı (sonlandırıcı iş parçacığı - eğer öldürürseniz her türlü kötü şeyi gerçekleştirir) tarafından temizlenmesi için özel bir sıraya taşınır. Bu, nesnelerinizin daha uzun süre asılı kalması ve potansiyel olarak daha fazla çöp koleksiyonunu zorlaması anlamına gelir.

Yani, tüm bunlar sadece mümkün olduğunda kaynakları temizlemek için IDisposable'ı kullanmak istediğiniz noktayı eve götürmek ve sonlandırıcıyı kullanmanın yollarını ciddi bir şekilde bulmaya çalışmaktır. Uygulamanızın yararına olacaktır.

Burada zaten çok iyi tartışmalar var ve partiye biraz geç kaldım, ama kendime birkaç puan eklemek istedim.

• Çöp Toplayıcı sizin için hiçbir zaman doğrudan bir Dispose yöntemi yürütmez.
• GC , sonlandırıcıları hissettiğinde yürütür.
• Bir sonlandırıcıya sahip nesneler için kullanılan yaygın bir desen, açık bir Dispose çağrısı yerine sonlandırma nedeniyle çağrının yapıldığını belirtmek için yanlış yerleştirilen Dispose (bool çöken) olarak tanımlanan bir yöntem çağırmasını sağlamaktır.
• Bunun nedeni, bir nesneyi sonlandırırken diğer yönetilen nesneler hakkında varsayımlarda bulunmanın güvenli olmamasıdır (zaten tamamlanmış olabilirler).

class SomeObject : IDisposable {
 IntPtr _SomeNativeHandle;
 FileStream _SomeFileStream;

 // Something useful here

 ~ SomeObject() {
  Dispose(false);
 }

 public void Dispose() {
  Dispose(true);
 }

 protected virtual void Dispose(bool disposing) {
  if(disposing) {
   GC.SuppressFinalize(this);
   //Because the object was explicitly disposed, there will be no need to 
   //run the finalizer.  Suppressing it reduces pressure on the GC

   //The managed reference to an IDisposable is disposed only if the 
   _SomeFileStream.Dispose();
  }

  //Regardless, clean up the native handle ourselves.  Because it is simple a member
  // of the current instance, the GC can't have done anything to it, 
  // and this is the onlyplace to safely clean up

  if(IntPtr.Zero != _SomeNativeHandle) {
   NativeMethods.CloseHandle(_SomeNativeHandle);
   _SomeNativeHandle = IntPtr.Zero;
  }
 }
}

Bu basit sürüm, ancak bu modelde sizi harekete geçirebilecek birçok nüans var.

• IDisposable.Dispose için yapılan sözleşme, birden çok kez çağrılmasının güvenli olması gerektiğini belirtir (zaten atılan bir nesneye Dispose çağrılması hiçbir şey yapmamalıdır)
• Tek kullanımlık nesnelerin kalıtım hiyerarşisini, özellikle farklı katmanlar yeni Tek Kullanımlık ve yönetilmeyen kaynaklar getiriyorsa, düzgün bir şekilde yönetmek çok karmaşık olabilir. Yukarıdaki desende Dispose (bool), geçersiz kılınmasına izin vermek için sanaldır, ancak hataya açık olduğunu düşünüyorum.

Bence, hem tek kullanımlık referansları hem de kesinleştirme gerektirebilecek yerel kaynakları içeren herhangi bir türden tamamen kaçınmak çok daha iyidir. SafeHandles, yerel olarak kendi sonlandırmalarını sağlayan yerel kaynakları tek kullanımlık haline getirerek bunu yapmak için çok temiz bir yol sağlar (P / Invoke sırasında asenkron bir istisna nedeniyle yerel bir tutamacın kaybedilebileceği bir dizi başka avantajla birlikte) .

Sadece bir SafeHandle tanımlamak önemsiz kılar:

private class SomeSafeHandle
 : SafeHandleZeroOrMinusOneIsInvalid {
 public SomeSafeHandle()
  : base(true)
  { }

 protected override bool ReleaseHandle()
 { return NativeMethods.CloseHandle(handle); }
}

İçeren türü aşağıdakileri basitleştirmenizi sağlar:

class SomeObject : IDisposable {
 SomeSafeHandle _SomeSafeHandle;
 FileStream _SomeFileStream;
 // Something useful here
 public virtual void Dispose() {
  _SomeSafeHandle.Dispose();
  _SomeFileStream.Dispose();
 }
}

Ben öyle düşünmüyorum. Dispose çağrıldığında kontrolünüz vardır, bu da teorik olarak diğer nesnelerin varlığı (örneğin) hakkında varsayımlar yapan imha kodu yazabileceğiniz anlamına gelir. Sonlandırıcının çağrılması üzerinde hiçbir kontrole sahip değilsiniz, bu yüzden sonlandırıcının sizin adınıza otomatik olarak Atma'yı çağırması iffy olurdu.

EDIT: Sadece emin olmak için gittim ve test ettim:

class Program
{
    static void Main(string[] args)
    {
        Fred f = new Fred();
        f = null;
        GC.Collect();
        GC.WaitForPendingFinalizers();
        Console.WriteLine("Fred's gone, and he's not coming back...");
        Console.ReadLine();
    }
}

class Fred : IDisposable
{
    ~Fred()
    {
        Console.WriteLine("Being finalized");
    }

    void IDisposable.Dispose()
    {
        Console.WriteLine("Being Disposed");
    }
}

Açıkladığınız durumda değil, Ama eğer varsa , GC sizin için Sonlandırıcıyı arayacaktır .

ANCAK. Bir sonraki çöp toplama, toplanmak yerine, sonlandırma que'sine girecek, her şey toplanacak, daha sonra sonlandırıcı olarak adlandırılacak. Bundan sonraki koleksiyon serbest bırakılacak.

Uygulamanızın bellek basıncına bağlı olarak, bir süre bu nesne oluşturma için bir gc'niz olmayabilir. Yani, bir dosya akışı veya bir db bağlantısı söz konusu olduğunda, yönetilmeyen kaynağın sonlandırıcı çağrısında bir süre serbest kalması için bir süre beklemeniz gerekebilir ve bu da bazı sorunlara neden olur.

Hayır, çağrılmadı.

Ancak bu, eşyalarınızı atmayı unutmayı kolaylaştırır. Sadece usinganahtar kelimeyi kullanın .

Bunun için aşağıdaki testi yaptım:

class Program
{
    static void Main(string[] args)
    {
        Foo foo = new Foo();
        foo = null;
        Console.WriteLine("foo is null");
        GC.Collect();
        Console.WriteLine("GC Called");
        Console.ReadLine();
    }
}

class Foo : IDisposable
{
    public void Dispose()
    {

        Console.WriteLine("Disposed!");
    }

GC imha çağrısı yapmaz . Bu olabilir senin finalizer diyoruz, ama bu bile her koşulda garanti edilmez.

Bunu ele almanın en iyi yolu hakkında bir tartışma için bu makaleye bakın .

IDisposable ile ilgili belgeler , davranışın yanı sıra örnek kodun oldukça açık ve ayrıntılı bir açıklamasını verir. GC Dispose(), arabirimdeki yöntemi çağırmaz , ancak nesneniz için sonlandırıcıyı çağırır.

IDisposable deseni öncelikle geliştirici tarafından çağrılacak şekilde oluşturulmuştur, IDispose uygulayan bir nesneniz varsa, geliştiricinin ya usinganahtar kelimenin nesnenin bağlamı etrafında uygulanması ya da doğrudan Dispose yöntemini çağırması gerekir.

Model için başarısız olan kasa, Dispose () yöntemini çağıran sonlandırıcıyı uygulamaktır. Bunu yapmazsanız, bazı bellek sızıntıları oluşturabilirsiniz, örneğin: Bazı COM sarıcıları oluşturursanız ve hiçbir zaman System.Runtime.Interop.Marshall.ReleaseComObject (comObject) öğesini (Dispose yöntemine yerleştirilir) çağırmazsanız.

Clr'de, sonlandırıcıları içeren nesneleri izlemek ve bunları GC tarafından Finalizer tablosunda saklamak ve bazı temiz sezgisel tarama GC tarafından başlatıldığında çağırmak dışında otomatik olarak Dispose yöntemlerini çağırmak için sihir yoktur.