Standard-Sammlung für IDisposable Objekte

Question

Ich habe eine Reihe von IDisposable Objekte in einer Nachschlagetabelle (plain old Dictionary <>, gerade jetzt), aber um den Code zu vereinfachen und Fehler zu vermeiden bin ich auf der Suche nach einer Sammlung Klasse, die " besitzt "die Dinge, die es hält, und um das Rad nicht neu zu erfinden" existiert solch eine Klasse bereits?

Die Spezifikation sollte so sein: - Die Sammlung muss Einwegartikel sein, und wenn es entsorgt wird, sollten alle enthaltenen Artikel ebenfalls entsorgt werden. - Immer wenn ein Artikel entfernt wird, wird zuerst Dispose() -d angezeigt. - Idealerweise wäre die Sammlung generisch mit der Typbeschränkung, die die IDisposable -ness des enthaltenen Typs erzwingt.

ich sorta Zweifel eine solche Klasse existiert, aber ich habe angenehm überrascht von der Existenz von ReadOnlyCollection und ObservableCollection vor ...

Wesentlichen überrascht, ich das Äquivalent der C++ STL-Container möchten aber dann für die CLR ;-).

Answer 1

Sie suchen nach CompositeDisposable.

using System.Reactive.Disposables; 

    ... 

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

Answer 2

Ich sehe, was Sie fragen, aber wie schwer ist es, Ihre eigene remove-Methode zu erstellen, die das Element entsorgt, bevor Sie es entfernen?

Answer 3

Von dem, was ich weiß, gibt es nur solche Exits wie IComponents - Container implements IContainer. Für generische IDisposable denke ich, dass Sie keine anderen Optionen haben, als "das Rad neu zu erfinden".

Answer 4

Denken Sie daran, dass Ihre Sammlung möglicherweise nicht die einzige ist, die die Einwegobjekte enthält ... Was ist, wenn ein anderes Objekt (außerhalb der Sammlung) auf eines dieser Objekte verweist? Wenn Sie es entsorgen, wenn die Sammlung entsorgt wird, was würde dann mit dem Objekt geschehen?

Wenn diese Objekte IDisposable für die Verwaltung einiger nicht verwalteter Ressourcen implementieren, stellen Sie sicher, dass sie auch die Finalisierung implementieren und nicht verwaltete Ressourcen dort entsorgen.

Answer 5

Wie wäre es etwa so:

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