DI: manejo de la vida de objetos identificables

Question

Estoy trabajando en mi contenedor DI/IoC OpenNETCF.IoC y tengo una solicitud (razonable) para agregar algún tipo de gestión del ciclo de vida para los artículos IDisposable en las colecciones de contenedores.

Mi idea actual es que, como no puedo consultar un objeto para ver si ha sido eliminado, y no puedo obtener un evento para cuando haya sido eliminado, tengo que crear alguna forma de contenedor para los objetos que un desarrollador quiere que se administre el marco.

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

Lo que estoy considerando es la adición de un nuevo método (también:

En este momento los objetos pueden ser añadido con AñadirNuevo (por razones de simplicidad asumiremos que sólo hay una sobrecarga y no hay Agregar)

grupo de ellos, pero se obtiene la imagen):

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

Cuando el DisposableWrappedObject se ve así:

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

Ahora, cuando un elemento se agrega al contenedor mediante AddNewDIsposable, también se agrega un controlador de eventos para que cuando se disipe (a través del contenedor) el marco lo elimine de la colección subyacente.

De hecho, tengo esto implementado y está pasando las pruebas unitarias, pero estoy buscando opiniones sobre dónde podría romperse, o cómo podría hacerse más "amigable" para el desarrollador consumidor.

EDIT 1

Puesto que no era una cuestión de cómo se utiliza el evento Eliminación, aquí hay un código (que se corta a lo que es importante):

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

Tal vez me falta algo, pero ¿por qué agregar nuevos métodos a la API? Cuando se agrega un objeto al contenedor, se puede agregar para verificar si es IDisposable y manejarlo de manera adecuada si es así.

También me pregunto si necesita el destructor. Suponiendo que el contenedor es IDisposable (como el de Unity), puede implementar el Basic Dispose Pattern y ahorrar una gran cantidad de gastos generales del GC.

Algunas preguntas que pueden ser aplicables:

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