ASP.NET Response.Filter：对整个内容/完整响应

Question

I am attempting to create response filter in order to modify the html being produced by another web application.

As shown below I created a Response.Filter derived from Stream .

The Response.Filter writes in chunks, I end up with a big mess if the response is larger than a single chunk.

On Write , the content is cached to another MemoryStream to buffer all of the chunks.

On Flush , the full content, now in the MemoryStream is converted to a string and the filter logic kicks in.

The modified content is then written back out to the originating stream.

What is the proper implementation for a Response.Filter that works on the entire content at once?

HttpModule.cs :

using System;
using System.Web;

namespace ACME
{
    public class HttpModule : IHttpModule
    {
        void IHttpModule.Init(HttpApplication context)
        {
            context.BeginRequest += ContextBeginRequest;
        }

        private void ContextBeginRequest(object sender, EventArgs e)
        {
            HttpApplication app = sender as HttpApplication;

            if (app != null)
            {
                if ( app.Request.FilePath.ToLower().EndsWith(".aspx") )
                {
                    app.Response.Filter = new ACMEFilter(app.Response.Filter);
                }
            }
        }

        void IHttpModule.Dispose()
        {
            // Nothing to dispose; 
        }
    }
}

ACMEFilter.cs :

using System;
using System.IO;
using System.Web;
using System.Text;
using System.Text.RegularExpressions;

namespace ACME
{
    internal class ACMEFilter: Stream
    {
        private readonly Stream _outputStream;
        private MemoryStream _cachedStream = new MemoryStream(1024);

        public override bool CanRead
        {
            get { return true; }
        }

        public override bool CanSeek
        {
            get { return true; }
        }

        public override bool CanWrite
        {
            get { return true; }
        }

        public override long Length
        {
            get { return 0; }
        }

        public override long Position { get; set; }

        public ACMEFilter(Stream stream)
        {
            _outputStream = stream;
        }

        public override void Flush()
        {
            Encoding encoding = HttpContext.Current.Response.ContentEncoding;
            string content = encoding.GetString(_cachedStream.ToArray());

            // filter logic here!
            content += "";

            byte[] buffer = encoding.GetBytes(content);
            _cachedStream = new MemoryStream();
            _cachedStream.Write(buffer, 0, buffer.Length);

            _outputStream.Write(_cachedStream.ToArray(), 0, (int)_cachedStream.Length);
            _cachedStream.SetLength(0);

            _outputStream.Flush();
        }

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

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

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

        public override void Close()
        {
            _cachedStream.Close();
        }

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

web.config :

<system.webServer>
    <modules>
      <add name="ACME" type="ACME.HttpModule, ACME" preCondition="managedHandler" />
    </modules>
<system.webServer>

Answer 1

What is the proper implementation for a Response.Filter that works on the entire content at once?

By definition, a stream does not work on a piece of text/bytes all at once.

Also, Flush() may be called more than once on a stream, so it is invalid to write the headers in this method as it may end up putting them multiple times in the response.

---

app.Response.Filter = new ACMEFilter(app.Response.Filter);

The above seems to implement the decorator pattern (which is common with streams), but the implementation you posted doesn't have a constructor. Normally, you would pass the stream you are writing to to the constructor in order to wrap it, then override all of the methods and write to the inner stream instance. These overridden methods are where you need to put the custom logic for writing the output the way you want, storing any state as necessary to flag different sections of the stream for customization.

internal class ACMEFilter : Stream
{
    private readonly Stream _innerStream;

    public ACMEFilter(Stream innerStream)
    {
        _innerStream = innerStream;
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        // Implement custom filter logic here,
        // storing any flags as class-level variables as needed
        // to act as switches across many calls to this and other
        // methods of the stream.

        _innerStream.Write(buffer, offset, count);
    }

    // Other member overrides...
}

There is an article that explains more in depth how to create a response filter https://weblog.west-wind.com/posts/2009/Nov/13/Capturing-and-Transforming-ASPNET-Output-with-ResponseFilter that specifically covers the fact that the stream data needs to be processed in chunks as the application provides it, and offers an alternative approach.