DI: Gestion de la vie des objets IDisposable

Question

Je travaille donc sur mon conteneur DI/IoC OpenNETCF.IoC et j'ai une demande de fonctionnalité (raisonnable) pour ajouter une forme de gestion du cycle de vie pour les éléments IDisposable dans les collections de conteneurs. Ma pensée actuelle est que, puisque je ne peux pas interroger un objet pour voir s'il a été éliminé, et je ne peux pas obtenir un événement pour quand il a été éliminé, que je dois créer une forme d'emballage pour les objets qu'un développeur veut que le framework gère.

objets En ce moment, on peut ajouter avec AddNew (par souci de simplicité, nous supposons qu'il n'y a qu'une surcharge et il n'y a pas Ajouter):

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

Ce que je considère est l'ajout d'une nouvelle méthode (bien groupe d'entre eux, mais vous obtenez l'image):

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

Lorsque le DisposableWrappedObject ressemble à ceci:

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

Maintenant, lorsqu'un élément est ajouté au conteneur via AddNewDIsposable, un gestionnaire d'événements est également ajouté de sorte que lorsqu'il est mis au rebut (via l'encapsuleur), le framework le supprime de la collection sous-jacente. En fait, j'ai implémenté cela et il passe les tests unitaires, mais je cherche des avis sur où cela pourrait être cassé, ou comment il pourrait être rendu plus "amical" pour le développeur consommateur.

EDIT 1

Comme il y avait une question sur la façon dont l'événement cédante est utilisé, voici un code (coupé à ce qui est important):

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

Peut-être que je manque quelque chose, mais pourquoi ajouter de nouvelles méthodes à l'API? Lorsqu'un objet est ajouté au conteneur, vous pouvez l'analyser pour vérifier s'il est IDisposable et le gérer de manière appropriée si c'est le cas. Je me demande aussi si vous avez besoin du destructeur. En supposant que le conteneur est IDisposable (comme celui de Unity), vous pouvez simplement implémenter le Basic Dispose Pattern et économiser beaucoup de temps système.

Certaines questions qui peuvent être applicables:

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