DI: Behandeln der Lebensdauer von IDisposable Objects

Question

So arbeite ich an meinem DI/IoC-Container OpenNETCF.IoC und ich habe eine (sinnvolle) Feature-Anfrage, um eine Form von Lifecycle-Management für IDisposable Elemente in den Containersammlungen hinzuzufügen.

Mein aktuelles Denken ist, dass, da ich ein Objekt nicht abfragen kann, um zu sehen, ob es entsorgt wurde, und ich kein Ereignis abrufen kann, wenn es entsorgt wurde, dass ich eine Art Wrapper für Objekte erstellen muss dass ein Entwickler das Framework verwalten möchte.

Rechts-Objekte können jetzt mit AddNew hinzugefügt werden (der Einfachheit halber nehmen wir an, es gibt nur eine Überlastung und es gibt keine Add):

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

Was ich erwägt eine neue Methode Hinzufügen (gut Gruppe von ihnen, aber Sie bekommen das Bild):

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

Wo die DisposableWrappedObject wie folgt aussieht:

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

Wenn nun ein Element über AddNewDIsposable zum Container hinzugefügt wird, wird auch ein Eventhandler hinzugefügt, so dass das Framework es aus der zugrunde liegenden Sammlung entfernt, sobald es Disposed (über den Wrapper) erhält.

Ich habe dies tatsächlich implementiert und es besteht die Unit-Tests, aber ich bin auf der Suche nach Meinungen darüber, wo dies möglicherweise gebrochen wird, oder wie es für den konsumierenden Entwickler "freundlicher" gemacht werden könnte.

EDIT 1

Da es eine Frage, wie die Entsorgung Ereignis verwendet wird, hier einige Code (getrimmt, was wichtig ist):

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

Vielleicht bin ich etwas fehlt, aber Warum fügen Sie der API neue Methoden hinzu? Wenn ein Objekt zum Container hinzugefügt wird, können Sie es als Vorlage verwenden, um zu prüfen, ob es IDisposable ist, und es gegebenenfalls zu behandeln.

Ich frage mich auch, ob Sie den Destruktor brauchen. Angenommen, der Container ist IDisposable (wie bei Unity), können Sie einfach Basic Dispose Pattern implementieren und viel GC-Overhead sparen.

einige Fragen, die anwendbar sein können:

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