Come si "forchetta" un flusso in .NET?

Question

Come discussed before, quando un BinaryReader o BinaryWriter viene chiuso, anche il suo Stream sottostante viene chiuso (aargh). Prendi in considerazione questa situazione: una routine R riceve un MemoryStream, ad esempio M; Vorrei scrivere alcune cose su M e poi passarlo a un'altra routine per ulteriori elaborazioni (non necessariamente scrivere). Per comodità, mi piacerebbe avvolgere M in un BinaryWriter per scrivere. Dopo aver scritto, ho finito con il BinaryWriter ma non con M.

void R(MemoryStream M) 
{ 
    using (B = new BinaryWriter(M)) 
    { 
     // write some stuff using B 
    } 

    S(M); // now pass M to another routine for further processing 
} 

Ma, non posso smaltire la BinaryStream senza chiudere M.

D: Esiste un modo per eseguire una delle seguenti azioni?

• estrarre il byte sottostante [] da un MemoryStream,
• clone un flusso
• riapre un flusso dopo che è stato chiuso

Answer 1

Grazie a diversi utenti che hanno suggerito ToArray, sono stato indirizzato alla risposta corretta, che è "M.GetBuffer". ToArray non è male, ma

• fa una copia
• ottiene solo una parte del buffer

GetBuffer afferra solo un riferimento al byte sottostante [], che è quello che sto dopo.

Answer 2

Un po approccio naive consiste nell'utilizzare

byte buf[] = MemoryStream.ToArray(); 

Per copiare il contenuto del flusso in un array di byte. È possibile attivare nuovamente in un flusso con

MemoryStream ms = new MemoryStream(buf); 

Answer 3

È possibile:

• chiamata M.ToArray() per ottenere il flusso come un array di byte.
• sottoclasse BinaryWriter e sovrascrivere il metodo Dispose per impedire la chiusura del flusso di bambino

Answer 4

accoring al this M.Clone(); dovrebbe funzionare. Ma potrei sbagliarmi ...

Answer 5

Si dovrebbe meglio ottenere il buffer di byte sottostante [] utilizzando

byte[] buffer = ms.GetBuffer(); 

E poi copiare i dati di byte utilizzando il metodo Array.Copy(). Sei libero di creare un nuovo flusso con esso.

Answer 6

È possibile utilizzare le cose come il MiscUtil.IO.NonClosingStreamWrapper in MiscUtil, che avvolge un Stream e semplicemente ignora Close/Dispose richieste. Solo per questo scopo.

void R(MemoryStream M) 
{ 
    using (B = new BinaryWriter(new NonClosingStreamWrapper(M))) 
    { 
     // write some stuff using B 
    } 

    S(M); // now pass M to another routine for further processing 
}  

Answer 7

solo aggiungere che qui, una soluzione molto semplice sarebbe non di smaltire() lo scrittore.

void R(MemoryStream M) 
{ 
    B = new BinaryWriter(M); 

    // write some stuff using B   
    B.Flush(); 
    S(M); // now pass M to another routine for further processing 
} 

Ora ci si deve solo preoccupare di mantenere B nell'ambito, che sarà durante R().

Questa potrebbe non essere la soluzione migliore qui, ma vale la pena notare che i Lettori e gli Scrittori non hanno bisogno di Smaltimento.