IDisposable'ın tüm sınıflarınıza yayılmasını nasıl önlersiniz?

Bu basit sınıflarla başlayın ...

Diyelim ki böyle basit bir sınıf setim var:

class Bus
{
    Driver busDriver = new Driver();
}

class Driver
{
    Shoe[] shoes = { new Shoe(), new Shoe() };
}

class Shoe
{
    Shoelace lace = new Shoelace();
}

class Shoelace
{
    bool tied = false;
}

A Bus, bir Driver, Driveriki Shoes, her Shoebiri bir Shoelace. Hepsi çok aptalca.

Ayakkabı Bağına IDisposable nesnesi ekleme

Daha sonra, üzerinde bazı işlemlerin Shoelaceçok iş parçacıklı olabileceğine karar verdim , bu yüzden EventWaitHandleiletişim kurmak için iş parçacığı için bir ekledim. Yani Shoelaceşimdi şöyle görünür:

class Shoelace
{
    private AutoResetEvent waitHandle = new AutoResetEvent(false);
    bool tied = false;
    // ... other stuff ..
}

Ayakkabı Bağı Üzerinde Kullanılabilir ID

Ancak şimdi Microsoft'un FxCop şikayet edecek: "Aşağıdaki IDisposable türlerin üyelerini oluşturduğu için 'Shoelace' üzerinde IDisposable uygulayın: 'EventWaitHandle'."

Tamam, uygulamak IDisposableüzerinde Shoelaceve benim temiz küçük sınıf bu korkunç karmaşa haline gelir:

class Shoelace : IDisposable
{
    private AutoResetEvent waitHandle = new AutoResetEvent(false);
    bool tied = false;
    private bool disposed = false;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    ~Shoelace()
    {
        Dispose(false);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                if (waitHandle != null)
                {
                    waitHandle.Close();
                    waitHandle = null;
                }
            }
            // No unmanaged resources to release otherwise they'd go here.
        }
        disposed = true;
    }
}

Veya (yorumcular tarafından belirtildiği gibi) Shoelacekendisi yönetilmeyen kaynak olmadığından Dispose(bool)ve Destructor'a ihtiyaç duymadan daha basit atma uygulamasını kullanabilirim :

class Shoelace : IDisposable
{
    private AutoResetEvent waitHandle = new AutoResetEvent(false);
    bool tied = false;

    public void Dispose()
    {
        if (waitHandle != null)
        {
            waitHandle.Close();
            waitHandle = null;
        }
        GC.SuppressFinalize(this);
    }
}

Dezavantajlı yayılırken dehşet içinde izleyin

Doğru bu sabit. Ama şimdi FxCop Shoeyaratan bir şikayet edecek Shoelace, bu yüzden de Shoeolmalı IDisposable.

Ve Driveroluşturur Shoeböylece Driverolmalıdır IDisposable. Ve Busoluşturur Driverböylece Busolmalı IDisposablevb vb.

Birdenbire yaptığım küçük değişiklik Shoelacebana çok fazla iş çıkarıyor ve patronum neden Busdeğişiklik yapmak için ödeme yapmam gerektiğini merak ediyor Shoelace.

Soru

Bu yayılmayı nasıl önlersiniz IDisposable, ancak yine de yönetilmeyen nesnelerinizin uygun şekilde atılmasını sağlarsınız?

IDisposable'ın yayılmasını gerçekten "engelleyemezsiniz". Bazı sınıfların atılması gerekir AutoResetEvent, ve en etkili yol, Dispose()finalizörlerin yükünü önlemek için bunu yöntemde yapmaktır . Ancak bu yöntemin bir şekilde çağrılması gerekir, bu yüzden tam olarak örneğinizde olduğu gibi IDisposable'ı içine alan veya içeren sınıflar bunları atmak zorundadır, bu yüzden de tek kullanımlık olmalılar, vb.

• Mümkünse IDisposable sınıfları kullanmaktan kaçının, olayları tek bir yerde kilitleyin veya bekleyin, pahalı kaynakları tek bir yerde tutun vb
• bunları yalnızca ihtiyacınız olduğunda oluşturun ve hemen ardından atın ( usingdesen)

Bazı durumlarda, isteğe bağlı bir durumu desteklediğinden IDisposable yok sayılabilir. Örneğin, WaitHandle, adlandırılmış bir Mutex'i desteklemek için IDisposable uygular. Bir ad kullanılmıyorsa, Dispose yöntemi hiçbir şey yapmaz. MemoryStream başka bir örnektir, sistem kaynağı kullanmaz ve Dispose uygulaması da hiçbir şey yapmaz. Yönetilmeyen bir kaynağın kullanılıp kullanılmadığı konusunda dikkatli düşünmek öğretici olabilir. Böylece .net kütüphaneleri için kullanılabilir kaynakları inceleyebilir veya bir kod çözücü kullanabilirsiniz.

Doğruluk açısından, bir üst nesnenin şimdi tek kullanımlık olması gereken bir alt nesne oluşturup sahip olması durumunda, IDisposable'ın bir nesne ilişkisi yoluyla yayılmasını önleyemezsiniz. FxCop bu durumda doğrudur ve üst öğe imkansız olmalıdır.

Yapabileceğiniz şey, nesne hiyerarşinizde bir yaprak sınıfına IDisposable eklenmesini önlemektir. Bu her zaman kolay bir iş değildir, ancak ilginç bir alıştırmadır. Mantıksal açıdan bakıldığında, bir ShoeLace'ın tek kullanımlık olması gerekmiyor. Buraya bir WaitHandle eklemek yerine, kullanıldığı noktada bir ShoeLace ve WaitHandle arasında bir ilişki eklemek de mümkündür. En basit yol Sözlük örneğidir.

WaitHandle'ı, WaitHandle'ın gerçekte kullanıldığı noktadaki bir harita aracılığıyla gevşek bir ilişkilendirmeye taşıyabilirseniz, bu zinciri kırabilirsiniz.

Yayılmasını önlemek IDisposableiçin, tek bir yöntemin içindeki tek kullanımlık bir nesnenin kullanımını kapsüllemeye çalışmalısınız. ShoelaceFarklı tasarım yapmaya çalışın :

class Shoelace { 
  bool tied = false; 

  public void Tie() {

    using (var waitHandle = new AutoResetEvent(false)) {

      // you can even pass the disposable to other methods
      OtherMethod(waitHandle);

      // or hold it in a field (but FxCop will complain that your class is not disposable),
      // as long as you take control of its lifecycle
      _waitHandle = waitHandle;
      OtherMethodThatUsesTheWaitHandleFromTheField();

    } 

  }
} 

Bekleme kolunun kapsamı Tie yöntemle ve sınıfın tek kullanımlık bir alana sahip olması gerekmez ve bu nedenle tek kullanımlık olması gerekmez.

Bekleme tutamacı, içinde bir uygulama ayrıntısı olduğundan Shoelace, bildirgesine yeni bir arabirim eklemek gibi genel arabirimini hiçbir şekilde değiştirmemelidir. Artık tek kullanımlık bir alana ihtiyacınız olmadığında ne olacak, IDisposablebeyanı kaldıracak mısınız? Shoelace Soyutlamayı düşünürseniz , bunun gibi altyapı bağımlılıkları tarafından kirletilmemesi gerektiğini çabucak fark edersiniz IDisposable. IDisposablesoyutlaması deterministik temizlik gerektiren bir kaynağı içine alan sınıflar için ayrılmalıdır; yani, atılabilirliğin soyutlamanın bir parçası olduğu sınıflar için .

Temel olarak Kompozisyon veya Toplama'yı Tek Kullanımlık sınıflarla karıştırdığınızda olan şey budur. Belirtildiği gibi, ilk çıkış yolu waitHandle'ı ayakkabı bağı dışına çıkarmaktır.

Bunu söyledikten sonra, yönetilmeyen kaynaklarınız olmadığında Tek Kullanımlık kalıbı önemli ölçüde azaltabilirsiniz. (Hala bunun için resmi bir referans arıyorum.)

Ancak yıkıcıyı ve GC'yi atlayabilirsiniz.SuppressFinalize (this); ve belki de sanal boşluğu biraz temizleyin.

İlginçtir Driver, yukarıdaki gibi tanımlanırsa:

class Driver
{
    Shoe[] shoes = { new Shoe(), new Shoe() };
}

Daha sonra Shoeyapıldığında IDisposable, FxCop (v1.36) olması Drivergerektiği gibi şikayet etmiyor IDisposable.

Ancak bu şekilde tanımlanırsa:

class Driver
{
    Shoe leftShoe = new Shoe();
    Shoe rightShoe = new Shoe();
}

o zaman şikayet edecek.

Bunun bir çözümden ziyade FxCop'un sadece bir sınırlaması olduğundan şüpheleniyorum, çünkü ilk versiyonda Shoeörnekler hala yaratılıyor Driverve hala bir şekilde bertaraf edilmesi gerekiyor.

Tasarımınızı çok sıkı bir şekilde tutarsanız, IDisposable'ın yayılmasını önlemenin teknik bir yolu olduğunu düşünmüyorum. O zaman tasarımın doğru olup olmadığını merak etmeliyiz.

Örneğinizde, sanırım ayakkabının ayakkabı bağına sahip olması mantıklıdır ve belki de sürücünün ayakkabılarına sahip olması gerekir. Ancak, otobüs sürücüye sahip olmamalıdır. Tipik olarak, otobüs sürücüleri hurdalığa giden otobüsleri izlemez :) Sürücüler ve ayakkabılar söz konusu olduğunda, sürücüler nadiren kendi ayakkabılarını yaparlar, yani gerçekten onlara "sahip olmazlar".

Alternatif bir tasarım şunlar olabilir:

class Bus
{
   IDriver busDriver = null;
   public void SetDriver(IDriver d) { busDriver = d; }
}

class Driver : IDriver
{
   IShoePair shoes = null;
   public void PutShoesOn(IShoePair p) { shoes = p; }
}

class ShoePairWithDisposableLaces : IShoePair, IDisposable
{
   Shoelace lace = new Shoelace();
}

class Shoelace : IDisposable
{
   ...
}

Yeni tasarım maalesef daha karmaşıktır, çünkü ayakkabı ve sürücülerin somut örneklerini somutlaştırmak ve atmak için ekstra sınıflar gerektirir, ancak bu komplikasyon çözülmekte olan sorunun doğasında vardır. İyi olan şey, otobüslerin artık ayakkabı bağcığının imha edilmesi için artık tek kullanımlık olması gerekmemesidir.

Konversiyon Kontrol kullanmaya ne dersiniz?

class Bus
{
    private Driver busDriver;

    public Bus(Driver busDriver)
    {
        this.busDriver = busDriver;
    }
}

class Driver
{
    private Shoe[] shoes;

    public Driver(Shoe[] shoes)
    {
        this.shoes = shoes;
    }
}

class Shoe
{
    private Shoelace lace;

    public Shoe(Shoelace lace)
    {
        this.lace = lace;
    }
}

class Shoelace
{
    bool tied;
    private AutoResetEvent waitHandle;

    public Shoelace(bool tied, AutoResetEvent waitHandle)
    {
        this.tied = tied;
        this.waitHandle = waitHandle;
    }
}

class Program
{
    static void Main(string[] args)
    {
        using (var leftShoeWaitHandle = new AutoResetEvent(false))
        using (var rightShoeWaitHandle = new AutoResetEvent(false))
        {
            var bus = new Bus(new Driver(new[] {new Shoe(new Shoelace(false, leftShoeWaitHandle)),new Shoe(new Shoelace(false, rightShoeWaitHandle))}));
        }
    }
}