Warum entsorgt ein Stream, wenn sein Brenner entsorgt wird?

Question

Betrachten Sie den folgenden Code ein:

using (var ms = new MemoryStream()) 
{ 
    using(var writer = BinaryWriter(ms)) 
    { 
     writer.Write(/*something*/); 
     writer.Flush(); 
    } 

    Assert.That(ms.Length > 0); // Throws ObjectDisposedException 
} 

Auf der einen Seite, ein Einweg-Objekt sollte es die Ressourcen verfügen; Ich bekomme das, aber auf der anderen Seite, das Objekt nicht erstellt und besitzt diese Ressource nicht, es wurde zur Verfügung gestellt -> Calling Code sollte die Verantwortung dafür übernehmen ... nein?

Ich kann nicht an andere Situationen wie diese denken, aber ist es ein einheitliches Muster im Rahmen für jede Klasse, die Einwegobjekte erhält, um sie auf eigene Weise zu entsorgen?

Answer 1

Es gibt eine implizite Annahme, dass Sie nur einen Writer pro Stream haben, also übernimmt der Writer den Besitz des Streams aus Bequemlichkeit - Sie haben dann wahrscheinlich eine Sache zu bereinigen.

Aber ich stimme zu; das ist nicht immer richtig und oft unbequem. Einige Implementierungen (DeflateStream, GZipStream, zum Beispiel) erlauben Ihnen zu wählen. Andernfalls besteht die einzige echte Option darin, einen Dummy-Stream zwischen den Schreiber und den zugrunde liegenden Stream zu injizieren; IIRC gibt es eine NonClosingStreamWrapper in Jon Skeet „MiscUtil“ Bibliothek, die tut genau dies: http://www.yoda.arachsys.com/csharp/miscutil/

Usage wie etwas sein würde:

using (var ms = new MemoryStream()) 
{ 
    using(var noClose = new NonClosingStreamWrapper(ms)) 
    using(var writer = BinaryWriter(noClose)) 
    { 
        writer.Write(/*something*/); 
        writer.Flush(); 
    } 

    Assert.That(ms.Length > 0); 
} 

Answer 2

Ich stimme Ihnen vollkommen zu. Dies ist kein konsistentes Verhalten, aber es wurde so implementiert. Es gibt comments am Ende der Dokumentation über dieses Verhalten, das nicht sehr intuitiv ist. Alle Stream-Writer nehmen nur den zugrunde liegenden Stream in Besitz und entsorgen ihn. Persönlich habe ich immer Nest meine using Anweisung wie folgt:

using (var ms = new MemoryStream()) 
using(var writer = BinaryWriter(ms)) 
{ 
    writer.Write(/*something*/); 
} 

, so dass ein Code wie die, die Sie in der Assert setzen sollte nicht geschrieben werden.

Answer 3

Das Richtige getan hätte Parameter einen Konstruktor haben gewesen, Der Streamwriter zeigt an, ob der Stream bei dem Konstruktor entsorgt werden soll. Da Microsoft dies nicht getan hat, kann es sinnvoll sein, eine NonDisposingStream-Klasse (Of T as Stream) zu definieren, die einen Stream umschließt, aber keinen Dispose-Aufruf an den umschlossenen Stream weitergibt. Man könnte dann einen neuen NonDisposingStream an den Konstruktor eines StreamWriter übergeben, und der zugrunde liegende Stream wäre sicher vor der Entsorgung (es wäre natürlich notwendig, den Stream selbst zu beseitigen).

Ein Objekt, das über ein übergebenes Objekt verfügen kann, ist nützlich. Während ein solches Verhalten nicht mit dem üblichen Muster des Erschaffenden eines Objekts zusammenfällt, gibt es oft Situationen, in denen der Schöpfer eines Objekts keine Ahnung hat, wie lange das Objekt tatsächlich benötigt wird. Es kann beispielsweise erwartet werden, dass eine Methode einen neuen StreamWriter erstellt, der einen neuen Stream verwendet. Der Besitzer des StreamWriter weiß, wann er entsorgt werden sollte, kennt aber möglicherweise nicht die Existenz des inneren Streams. Der Ersteller des inneren Streams wird keine Ahnung haben, wie lange der äußere StreamWriter verwendet wird. Wenn man den StreamWriter mit dem Stream "aushändigt", wird das Entsorgungsproblem in diesem speziellen Fall gelöst.

Answer 4

Ich schlage vor, diese Wrapper-Klasse:

public class BetterStreamWriter : StreamWriter 
{ 
    private readonly bool _itShouldDisposeStream; 

    public BetterStreamWriter(string filepath) 
     :base(filepath) 
    { 
     _itShouldDisposeStream = true; 
    } 

    public BetterStreamWriter(Stream stream) 
     : base(stream) 
    { 
     _itShouldDisposeStream = false; 
    } 

    protected override void Dispose(bool disposing) 
    { 
     base.Dispose(disposing && _itShouldDisposeStream); 
    } 
} 

Objekte sollten nicht Sachen entsorgen sie instanziiert nicht. Wenn es sich um einen Datei-Stream-Writer handelt, sollte dieser entsorgt werden. Wenn es sich um einen externen Stream handelt, sollte dies nicht der Fall sein.

Sollte der Pfad zum Öffnen der Datei an erster Stelle nicht implementiert sein.Dies verletzt das Prinzip der einfachen Verantwortung, da das Objekt sowohl das Schreiben als auch die Lebensdauer der Datei verwaltet.