C'è un modo per chiudere uno StreamWriter senza chiudere il suo BaseStream?

Il mio problema principale è che quando usingchiama Disposea StreamWriter, elimina anche lo BaseStream(stesso problema con Close).

Ho una soluzione alternativa per questo, ma come puoi vedere, si tratta di copiare lo stream. C'è un modo per farlo senza copiare lo stream?

Lo scopo di ciò è ottenere il contenuto di una stringa (originariamente letta da un database) in uno stream, in modo che lo stream possa essere letto da un componente di terze parti.
NB : non posso cambiare il componente di terze parti.

public System.IO.Stream CreateStream(string value)
{
    var baseStream = new System.IO.MemoryStream();
    var baseCopy = new System.IO.MemoryStream();
    using (var writer = new System.IO.StreamWriter(baseStream, System.Text.Encoding.UTF8))
    {
        writer.Write(value);
        writer.Flush();
        baseStream.WriteTo(baseCopy); 
    }
    baseCopy.Seek(0, System.IO.SeekOrigin.Begin);
    return baseCopy;
}

Usato come

public void Noddy()
{
    System.IO.Stream myStream = CreateStream("The contents of this string are unimportant");
    My3rdPartyComponent.ReadFromStream(myStream);
}

Idealmente sto cercando un metodo immaginario chiamato BreakAssociationWithBaseStream, ad es

public System.IO.Stream CreateStream_Alternate(string value)
{
    var baseStream = new System.IO.MemoryStream();
    using (var writer = new System.IO.StreamWriter(baseStream, System.Text.Encoding.UTF8))
    {
        writer.Write(value);
        writer.Flush();
        writer.BreakAssociationWithBaseStream();
    }
    return baseStream;
}

Se si utilizza .NET Framework 4.5 o versioni successive, è presente un overload StreamWriter che consente di chiedere al flusso di base di essere lasciato aperto quando il writer viene chiuso .

Nelle versioni precedenti di .NET Framework precedenti alla 4.5, si StreamWriter presume che sia il proprietario del flusso. Opzioni:

• Non smaltire il StreamWriter; basta sciacquarlo.
• Crea un wrapper di flusso che ignora le chiamate a Close/ Disposema invia tramite proxy tutto il resto. Ho un'implementazione di questo in MiscUtil , se vuoi prenderlo da lì.

.NET 4.5 ha un nuovo metodo per questo!

http://msdn.microsoft.com/EN-US/library/gg712853(v=VS.110,d=hv.2).aspx

public StreamWriter(
    Stream stream,
    Encoding encoding,
    int bufferSize,
    bool leaveOpen
)

Semplicemente non chiamare Disposeil StreamWriter. Il motivo per cui questa classe è usa e getta non è perché contiene risorse non gestite ma per consentire l'eliminazione del flusso che a sua volta potrebbe contenere risorse non gestite. Se la vita del flusso sottostante viene gestita altrove, non è necessario eliminare il writer.

Il flusso di memoria ha una proprietà ToArray che può essere utilizzata anche quando il flusso è chiuso. To Array scrive il contenuto del flusso in una matrice di byte, indipendentemente dalla proprietà Position. Puoi creare un nuovo stream in base allo stream in cui hai scritto.

public System.IO.Stream CreateStream(string value)
{
    var baseStream = new System.IO.MemoryStream();
    var baseCopy = new System.IO.MemoryStream();
    using (var writer = new System.IO.StreamWriter(baseStream, System.Text.Encoding.UTF8))
    {
        writer.Write(value);
        writer.Flush();
        baseStream.WriteTo(baseCopy); 
    }
    var returnStream = new System.IO.MemoryStream( baseCopy.ToArray());
    return returnStream;
}

È necessario creare un discendente dello StreamWriter e sovrascrivere il suo metodo dispose, passando sempre false al parametro disposing, forzerà la chiusura dello stream writer NON, lo StreamWriter chiama solo dispose nel metodo close, quindi non è necessario sovrascriverlo (ovviamente puoi aggiungere tutti i costruttori se vuoi, ne ho solo uno):

public class NoCloseStreamWriter : StreamWriter
{
    public NoCloseStreamWriter(Stream stream, Encoding encoding)
        : base(stream, encoding)
    {
    }

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