Comment puis-je "bifurquer" un flux dans .NET?

Question

En tant que discussed before, lorsqu'un BinaryReader ou un BinaryWriter est fermé, son Stream sous-jacent est également fermé (aargh). Considérez cette situation: une routine R est passée un MemoryStream, par exemple M; Je voudrais écrire quelques trucs à M et ensuite le passer à une autre routine pour plus de traitement (pas nécessairement d'écriture). Pour plus de commodité, je voudrais envelopper M dans un BinaryWriter pour écrire. Après l'écriture, j'en ai fini avec le BinaryWriter mais pas avec 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 
} 

Mais, je ne peux pas disposer de la BinaryStream sans fermer M.

Q: Y a-t-il un moyen de faire l'une des choses suivantes?

• extraire l'octet sous-jacent [] à partir d'un MemoryStream,
• clone un flux
• rouvre un flux après qu'il a été fermé

Answer 1

Merci à plusieurs qui ont suggéré ToArray, j'ai été conduit à la bonne réponse, qui est `M.GetBuffer '. ToArray est pas trop mal, mais il

• fait une copie
• obtient seulement une partie de la mémoire tampon

GetBuffer saisit simplement une référence à l'octet sous-jacent [], qui est ce que je suis après.

Answer 2

Une approche quelque peu naïve est d'utiliser

byte buf[] = MemoryStream.ToArray(); 

Pour copier le contenu du flux dans un tableau d'octets. Vous pouvez l'activer de nouveau dans un ruisseau avec

MemoryStream ms = new MemoryStream(buf); 

Answer 3

Vous pouvez:

• Appel M.ToArray() pour obtenir le flux comme un tableau d'octets.
• BinaryWriter Schéma et remplacer la méthode Dispose pour empêcher la fermeture du flux d'enfant

Answer 4

accoring à this M.Clone(); devrait marcher. Mais je peux me tromper ...

Answer 5

Vous devriez mieux obtenir l'octet sous-jacent [tampon] en utilisant

byte[] buffer = ms.GetBuffer(); 

Et puis copiez les données d'octets en utilisant la méthode Array.Copy(). Vous êtes libre de créer un nouveau flux avec celui-ci.

Answer 6

Vous pouvez utiliser des choses comme le MiscUtil.IO.NonClosingStreamWrapper dans MiscUtil, qui enveloppe un Stream et ne tient pas compte simplement Close/Dispose demandes. Pour juste ce but.Juste pour l'ajouter ici

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

, une solution très simple serait pas à Dispose() l'écrivain.

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 
} 

Maintenant, vous n'avez plus qu'à vous soucier de garder B dans la portée, ce qui sera le cas pendant R().

Ceci peut ne pas être la meilleure solution ici, mais il est intéressant de noter que les lecteurs et les rédacteurs n'ont pas besoin de se jeter.