Colección estándar para objetos IDisposable

Question

Tengo un montón de objetos IDisposable en una tabla de búsqueda (simple diccionario antiguo <>, ahora mismo), pero para simplificar el código y evitar errores, estoy buscando una clase de colección que " posee "los artículos que tiene, y para evitar reinventar la rueda, ¿existe tal clase?

La especificación debe ser que: - La colección debe ser desechable, y cuando se desecha, todos los artículos contenidos deben desecharse también. - Cuando se elimina un elemento, es Dispose() -d primero. - idealmente, la colección sería genérica con la restricción de tipo que impone el IDisposable -ness del tipo contenido.

sorta dudo existe una clase tal, pero me han sorprendido gratamente por la existencia de ReadOnlyCollection y ObservableCollection antes ...

Esencialmente, me gustaría que el equivalente de los contenedores STL C++, pero luego de el CLR ;-).

Answer 1

Está buscando CompositeDisposable.

using System.Reactive.Disposables; 

    ... 

    CompositeDisposable xs = new CompositeDisposable(Disposable.Empty); 
    xs.Add(Disposable.Empty); 
    xs.Add(Disposable.Empty); 
    xs.Dispose(); 

Answer 2

Veo lo que pregunta, pero ¿qué tan difícil es hacer su propio método de eliminación que elimina el elemento antes de eliminarlo?

Answer 3

Por lo que sé, solo hay salidas tales colección para IComponents - Container implements IContainer. Para IDsposable genérico, creo que no tienes más opciones que "reinventar la rueda".

Answer 4

Recuerde que su colección podría no ser la única que contiene los objetos desechables ... ¿Qué sucede si otro objeto (externo a la colección) hace referencia a uno de esos? Si se deshace de ella cuando la colección está dispuesta, ¿qué le pasaría al objeto?

Si estos objetos implementan IDisposable para la limpieza de algunos recursos no administrados, asegúrese de que implementen la finalización también y desechen los recursos no administrados allí.

Answer 5

¿Qué tal algo como esto:

public class DisposableEnumerable<T> : IEnumerable<T>, IDisposable where T : IDisposable 
{ 
    IEnumerable<T> Enumerable { get; } 

    public DisposableEnumerable(IEnumerable<T> enumerable) 
    { 
     Enumerable = enumerable; 
    } 

    public IEnumerator<T> GetEnumerator() 
    { 
     return Enumerable.GetEnumerator(); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return Enumerable.GetEnumerator(); 
    } 

    public void Dispose() 
    { 
     foreach(var disposable in Enumerable) 
     { 
      disposable.Dispose(); 
     } 
    } 
}