将字符串转换为内存流 - 内存流不可扩展？

Question

我试图将字符串写入内存流， 但失败并显示错误消息：

Memory stream is not expandable.

产生此问题的代码行：

context.Response.Filter = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(myPage));

有人有解决方法/解决方法吗？

堆栈跟踪：

[NotSupportedException: Memory stream is not expandable.]
   System.IO.MemoryStream.set_Capacity(Int32 value) +9385744
   System.IO.MemoryStream.EnsureCapacity(Int32 value) +50
   System.IO.MemoryStream.Write(Byte[] buffer, Int32 offset, Int32 count) +265
   System.Web.HttpWriter.FilterIntegrated(Boolean finalFiltering, IIS7WorkerRequest wr) +9155697
   System.Web.HttpResponse.FilterOutput() +159
   System.Web.CallFilterExecutionStep.System.Web.HttpApplication.IExecutionStep.Execute() +52
   System.Web.HttpApplication.ExecuteStep(IExecutionStep step, Boolean& completedSynchronously) +75

Answer 1

以下代码对我来说可以正常工作

public class Foo
{
    public static void Main()
    {
        var myPage = "test string";
        var repo =  new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(myPage));
    }
}

似乎正确的方法是使用默认构造函数创建MemoryStream

var repo = new System.IO.MemoryStream();

然后写入它

var stringBytes = System.Text.Encoding.UTF8.GetBytes(myPage);
repo.Write(stringBytes, 0, stringBytes.Length);

如果您希望能够正常读取流（例如使用 StreamReader），那么您还需要调用：

repo.Seek(0, SeekOrigin.Begin);

Answer 2

附加数据的自定义流会更合适。

经过最低限度的测试。假设您希望在刷新流时写入文本，然后只写入一次。

public class AppendTextFilter : Stream
{
    private Stream Filter { get; set; }
    private string Text { get; set; }
    private bool TextWritten { get; set; }

    public AppendTextFilter( Stream filter, string text )
    {
        this.Filter = filter;
        this.Text = text;
    }

    public override bool CanRead { get { return Filter.CanRead; } }

    public override bool CanSeek { get { return Filter.CanSeek; } }

    public override bool CanWrite { get { return Filter.CanWrite; } }

    public override void Flush()
    {
        if (!TextWritten)
        {
            var bytes = Encoding.UTF7.GetBytes( Text );
            Filter.Write( bytes, 0, bytes.Length );
            TextWritten = true;
        }
        Filter.Flush();
    }

    public override long Length { get { return Filter.Length + Text.Length; } }

    public override long Position
    {
        get
        {
            return Filter.Position;
        }
        set
        {
            Filter.Position = value;
        }
    }

    public override int Read( byte[] buffer, int offset, int count )
    {
        return Filter.Read( buffer, offset, count );
    }

    public override long Seek( long offset, SeekOrigin origin )
    {
        return Filter.Seek( offset, origin );
    }

    public override void SetLength( long value )
    {
        Filter.SetLength( value );
    }

    public override void Write( byte[] buffer, int offset, int count )
    {
        Filter.Write( buffer, offset, count );
    }
}

Answer 3

当您从一个字节数组创建MemoryStream 时，您实际上是在该数组周围创建了一个包装器。这意味着流的缓冲区一旦达到其容量就无法扩展。

不过，HttpResponse.Filter 本质上就是：过滤器。文档指出：

当您创建一个 Stream 对象并将 Filter 属性设置为 Stream 对象时，Write 发送的所有 HTTP 输出都会通过该过滤器。

所以数据最终被写入MemoryStream。因此，确切地知道您要通过此实现的目标会有所帮助，因为MemoryStream 不会成为有用的过滤器...

Answer 4

            byte[] buffer = File.ReadAllBytes("test.xml");
            XmlDocument doc = new XmlDocument();
            using (MemoryStream output = new MemoryStream())
            {
                using (MemoryStream ms = new MemoryStream(buffer ))
                {
                    doc.Load(ms);
                }
                // Make changes to your memory stream here
                doc.Save(output);//Output stream has the changes.
            }