DI: Tek Kullanımlık Nesnelerin Kullanım Süreci

Question

Bu yüzden DI/IoC Kapsayıcım OpenNETCF.IoC üzerinde çalışıyorum ve kapsayıcı koleksiyonlarda kimliği değiştirilebilen öğeler için bir tür yaşam döngüsü yönetimi eklemek için bir (makul) özellik isteğim var.

Şu anki düşüncem şu: Bir nesneyi yok edip edilmediğini görmek için bir nesneyi sorgulayamadığımdan ve ne zaman kullanıma sunulduğuna ilişkin bir olay alamıyorum, nesneler için bir çeşit sarıcı oluşturmam gerekiyor Bir geliştiricinin çerçeveyi yönetmesini istiyor. kuyu

public TTypeToBuild AddNew<TTypeToBuild>() { ... } 

Ne yeni bir yöntem ekliyor düşünüyorum (: Şu anda AddNew (basitlik uğruna sadece bir aşırı yük var ve hiçbir ekleme yoktur varsayıyoruz) ile eklenebilir nesnelerin

bunlardan grup, ama siz) resim elde:

public class DisposableWrappedObject<T> 
    where T : class, IDisposable 
{ 
    public bool Disposed { get; private set; } 
    public T Instance { get; private set; } 

    internal event EventHandler<GenericEventArgs<IDisposable>> Disposing; 

    internal DisposableWrappedObject(T disposableObject) 
    { 
     if (disposableObject == null) throw new ArgumentNullException(); 

     Instance = disposableObject; 
    } 

    ~DisposableWrappedObject() 
    { 
     Dispose(false); 
    } 

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

    protected virtual void Dispose(bool disposing) 
    { 
     lock(this) 
     { 
      if(Disposed) return; 

      EventHandler<GenericEventArgs<IDisposable>> handler = Disposing; 
      if(handler != null) 
      { 
       Disposing(this, new GenericEventArgs<IDisposable>(Instance)); 
      } 

      Instance.Dispose(); 

      Disposed = true; 
     } 
    } 
} 

: DisposableWrappedObject şöyle

public DisposableWrappedObject<IDisposable> AddNewDisposable<TTypeToBuild>() 
    where TTypeToBuild : class, IDisposable 
{ 
    ... 
} 

Şimdi, bir öğeye AddNewDIsposable aracılığıyla konteynere eklendiğinde, bir eventhandler de eklenir, böylece Dispose (wrapper aracılığıyla) alındığında çerçeve onu alttaki koleksiyondan kaldırır.

Aslında bunu uygulamıştım ve birim testlerini geçiyor, ancak bunun nerede kırılabileceğine veya tüketici geliştiricisine nasıl daha "dost" hale getirilebileceğine dair fikirler arıyorum.

private object AddNew(Type typeToBuild, string id, bool wrapDisposables) 
{ 
    .... 

    object instance = ObjectFactory.CreateObject(typeToBuild, m_root); 

    if ((wrapDisposables) && (instance is IDisposable)) 
    { 
     DisposableWrappedObject<IDisposable> dispInstance = new 
       DisposableWrappedObject<IDisposable>(instance as IDisposable); 
     dispInstance.Disposing += new 
       EventHandler<GenericEventArgs<IDisposable>>(DisposableItemHandler); 
     Add(dispInstance as TItem, id, expectNullId); 
     instance = dispInstance; 
    } 

    .... 

    return instance; 
} 

private void DisposableItemHandler(object sender, GenericEventArgs<IDisposable> e) 
{ 
    var key = m_items.FirstOrDefault(i => i.Value == sender).Key; 
    if(key == null) return; 
    m_items.Remove(key); 
} 

Answer 1

Belki bir şey eksik ama:

DÜZENLEME 1 Atılması olay nasıl kullanıldığına bir soru olmadığı için

, burada bazı kod (önemli olan şeylere kesilmiş) API'ye neden yeni yöntemler ekliyorsunuz? Bir nesneyi kapsayıcıya eklendiğinde, kimliğine uygun olup olmadığını kontrol edip, uygun şekilde işlemek için gönderilebilir.

Ayrıca yıkıcıya ihtiyacınız olup olmadığını da merak ediyorum. Konteynerin IDisposable olduğu varsayılırsa (Unity's gibi), sadece Basic Dispose Pattern'u uygulayabilir ve çok fazla GC yükünü kaydedebilirsiniz.

geçerli olabilecek bazı sorular

:

• How do you reconcile IDisposable and IoC?
• Can inversion of control and RAII play together?