追加到MemoryStream [英] Appending to MemoryStream

问题描述

我正在尝试将一些数据附加到流中.这对于 FileStream 效果很好，但由于固定的缓冲区大小，不适用于 MemoryStream .

I'm trying to append some data to a stream. This works well with FileStream, but not for MemoryStream due to the fixed buffer size.

将数据写入流的方法与创建流的方法是分开的(在下面的示例中，我已对其进行了大大的简化).创建流的方法不知道要写入流的数据长度.

The method which writes data to the stream is separated from the method which creates the stream (I've simplified it greatly in the below example). The method which creates the stream is unaware of the length of data to be written to the stream.

public void Foo(){
    byte[] existingData = System.Text.Encoding.UTF8.GetBytes("foo");
    Stream s1 = new FileStream("someFile.txt", FileMode.Append, FileAccess.Write, FileShare.Read);
    s1.Write(existingData, 0, existingData.Length);


    Stream s2 = new MemoryStream(existingData, 0, existingData.Length, true);
    s2.Seek(0, SeekOrigin.End); //move to end of the stream for appending

    WriteUnknownDataToStream(s1);
    WriteUnknownDataToStream(s2); // NotSupportedException is thrown as the MemoryStream is not expandable
}

public static void WriteUnknownDataToStream(Stream s)
{
   // this is some example data for this SO query - the real data is generated elsewhere and is of a variable, and often large, size.
   byte[] newBytesToWrite = System.Text.Encoding.UTF8.GetBytes("bar"); // the length of this is not known before the stream is created.
   s.Write(newBytesToWrite, 0, newBytesToWrite.Length);
}

我的想法是向该函数发送一个可扩展的 MemoryStream ，然后将返回的数据附加到现有数据中.

An idea I had was to send an expandable MemoryStream to the function, then append the returned data to the existing data.

public void ModifiedFoo()
{
   byte[] existingData = System.Text.Encoding.UTF8.GetBytes("foo");
   Stream s2 = new MemoryStream(); // expandable capacity memory stream

   WriteUnknownDataToStream(s2);

   // append the data which has been written into s2 to the existingData
   byte[] buffer = new byte[existingData.Length + s2.Length];
   Buffer.BlockCopy(existingData, 0, buffer, 0, existingData.Length);
   Stream merger = new MemoryStream(buffer, true);
   merger.Seek(existingData.Length, SeekOrigin.Begin);
   s2.CopyTo(merger);
}

有没有更好(更有效)的解决方案?

Any better (more efficient) solutions?

推荐答案

一种可能的解决方案是首先不限制 MemoryStream 的容量.如果您事先不知道需要写入的字节总数，请创建一个未指定容量的 MemoryStream 并将其用于两次写入.

A possible solution is not to limit the capacity of the MemoryStream in the first place. If you do not know in advance the total number of bytes you will need to write, create a MemoryStream with unspecified capacity and use it for both writes.

byte[] existingData = System.Text.Encoding.UTF8.GetBytes("foo");
MemoryStream ms = new MemoryStream();
ms.Write(existingData, 0, existingData.Length); 
WriteUnknownData(ms);

这无疑比从 byte [] 初始化 MemoryStream 的性能要差，但是如果您需要继续写入流，我相信这是您唯一的选项.

This will no doubt be less performant than initializing a MemoryStream from a byte[], but if you need to continue writing to the stream I believe it is your only option.

这篇关于追加到MemoryStream的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！