如何使用 OWIN 中间件组件检查 MVC 响应流？

这个问题以前曾以几种形式被问过，但我无法得到任何工作答案，我正在掉头发，不确定问题是否只是解决方案是两年前的，而且事情已经发生了变化。

如何安全地拦截自定义 Owin 中间件中的响应流 https://stackoverflow.com/questions/26214113/how-can-i-safely-intercept-the-response-stream-in-a-custom-owin-middleware- 我的代码基于此，看起来应该可以工作，但事实并非如此

OWIN OnSendingHeaders 回调 - 读取响应正文 https://stackoverflow.com/questions/17679644/owin-onsendingheaders-callback-reading-response-body?lq=1- 似乎是不同的 OWIN 版本，因为方法签名不起作用

我想要做的是编写一个可以检查来自 MVC 的响应流的 OMC。

我所做的（以及其他几次尝试）是添加一个将 context.Response.Body 设置为 MemoryStream 的 OMC，这样我就可以倒回它并检查下游组件写入的内容：

    public async Task Invoke(IDictionary<string, object> env)
    {

        IOwinContext context = new OwinContext(env);

        // Buffer the response
        var stream = context.Response.Body;
        var buffer = new MemoryStream();
        context.Response.Body = buffer;
        .......

我发现 MemoryStream 总是空的，除非我从另一个 OMC 写入它。因此，看起来下游 OMC 正在使用我的 MemoryStream，但 MVC 响应却没有，就好像 OWIN 管道在请求转到 MVC 之前完成一样，但这不对，不是吗？

完整代码：

public partial class Startup
{
    public void Configuration(IAppBuilder app)
    {
        ConfigureAuth(app);
        app.Use(new ResponseExaminerMiddleware());

        // Specify the stage for the OMC
        //app.UseStageMarker(PipelineStage.Authenticate);
    }


}




public class ResponseExaminerMiddleware
{
    private AppFunc next;

    public void Initialize(AppFunc next)
    {
        this.next = next;
    }

    public async Task Invoke(IDictionary<string, object> env)
    {

        IOwinContext context = new OwinContext(env);

        // Buffer the response
        var stream = context.Response.Body;
        var buffer = new MemoryStream();
        context.Response.Body = buffer;

        await this.next(env);

        buffer.Seek(0, SeekOrigin.Begin);
        var reader = new StreamReader(buffer);
        string responseBody = await reader.ReadToEndAsync();

        // Now, you can access response body.
        System.Diagnostics.Debug.WriteLine(responseBody);

        // You need to do this so that the response we buffered
        // is flushed out to the client application.
        buffer.Seek(0, SeekOrigin.Begin);
        await buffer.CopyToAsync(stream);

    }

}

对于它的价值，我还尝试了一个建议，其中将response.Body流设置为Stream子类，这样我就可以监视写入流的内容，奇怪的是调用了Stream.Write方法，但使用了一个空字节数组，从来没有任何实际内容...

MVC 不通过 OWIN 管道传递其请求。为了捕获 MVC 响应，我们需要创建捕获响应数据的自定义响应过滤器

/// <summary>
/// Stream capturing the data going to another stream
/// </summary>
internal class OutputCaptureStream : Stream
{
    private Stream InnerStream;
    public MemoryStream CapturedData { get; private set; }

    public OutputCaptureStream(Stream inner)
    {
        InnerStream = inner;
        CapturedData = new MemoryStream();
    }

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

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

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

    public override void Flush()
    {
        InnerStream.Flush();
    }

    public override long Length
    {
        get { return InnerStream.Length; }
    }

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

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

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

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

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

然后我们制作一个日志中间件，可以正确记录两种响应

public class LoggerMiddleware : OwinMiddleware
{
    public LoggerMiddleware(OwinMiddleware next): base(next)
    {
    }

    public async override Task Invoke(IOwinContext context)
    {
        //to intercept MVC responses, because they don't go through OWIN
        HttpResponse httpResponse = HttpContext.Current.Response;
        OutputCaptureStream outputCapture = new OutputCaptureStream(httpResponse.Filter);
        httpResponse.Filter = outputCapture;

        IOwinResponse owinResponse = context.Response;
        //buffer the response stream in order to intercept downstream writes
        Stream owinResponseStream = owinResponse.Body;
        owinResponse.Body = new MemoryStream();

        await Next.Invoke(context);

        if (outputCapture.CapturedData.Length == 0) {
            //response is formed by OWIN
            //make sure the response we buffered is flushed to the client
            owinResponse.Body.Position = 0;
            await owinResponse.Body.CopyToAsync(owinResponseStream);
        } else {   
            //response by MVC
            //write captured data to response body as if it was written by OWIN         
            outputCapture.CapturedData.Position = 0;
            outputCapture.CapturedData.CopyTo(owinResponse.Body);
        }

        LogResponse(owinResponse);
    }
}