3

我正在尝试使用一些自定义的 Owin 中间件来修改（在这种情况下，完全替换）特定情况下的响应流。

每当我发出一个触发我的中间件来替换响应的调用时，一切都会正常工作。仅当我拨打我的中间件未对其进行更改时才会出现此问题。此外，我只能在未被替换的 API 调用返回手动创建的 HttpResponseMessage 对象时发生错误。

例如调用这个 API：

public class testController : ApiController
{
    public HttpResponseMessage Get()
    {
         return Request.CreateResponse(HttpStatusCode.OK,new { message = "It worked." });
    }
}

工作正常，但这个类：

public class testController : ApiController
{
    public HttpResponseMessage Get()
    {
        HttpResponseMessage m = Request.CreateResponse();
        m.StatusCode = HttpStatusCode.OK;
        m.Content = new StringContent("It worked.", System.Text.Encoding.UTF8, "text/plain");
        return m;
    }
}

导致错误发生。（在这两种情况下，http://localhost:<port>/test都被调用。）

该错误会导致以下任一情况：

  • 导致 iisexpress.exe（或 w3wp.exe，如果在实际 IIS 中运行）因访问冲突而崩溃。

  • 抛出一个AccessViolationExceptionVisual Studio 捕获但无法执行任何操作的事件，因为它出现在外部代码中。当 Visual Studio 确实捕获异常时，我看到：

    An unhandled exception of type 'System.AccessViolationException' occurred in System.Web.dll

Additional information: Attempted to read or write protected memory. This is often an indication that other memory is corrupt.

显然，如果我不启用我的中间件，我根本就没有问题。此外，我只能在手动创建和返回 HttpResponseMessage 对象时导致问题发生，如第二类所示。

这是我的中间件类。它目前设置为在有人请求端点时简单地替换整个响应流，/replace无论管道中是否有其他任何东西对其进行了任何操作。

using Microsoft.Owin;
using Owin;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Threading.Tasks;
using Newtonsoft.Json;

using AppFunc = System.Func<
    System.Collections.Generic.IDictionary<string, object>,
    System.Threading.Tasks.Task
>;

namespace TestOwinAPI
{
    public class ResponseChangeMiddleware
    {
        AppFunc _next;

        public ResponseChangeMiddleware(AppFunc next, ResponseChangeMiddlewareOptions opts)
        {
            _next = next;
        }
        public async Task Invoke(IDictionary<string,object> env)
        {
            var ctx = new OwinContext(env);

            // create a new memory stream which will replace the default output stream
            using (var ms = new MemoryStream())
            {

                // hold on to a reference to the actual output stream for later use
                var outStream = ctx.Response.Body;

                // reassign the context's output stream to be our memory stream
                ctx.Response.Body = ms;

                Debug.WriteLine(" <- " + ctx.Request.Path);

                // allow the rest of the middleware to do its job
                await _next(env);

                // Now the request is on the way out.
                if (ctx.Request.Path.ToString() == "/replace")
                {

                    // Now write new response.
                    string json = JsonConvert.SerializeObject(new { response = "true", message = "This response will replace anything that the rest of the API might have created!" });
                    byte[] jsonBytes = System.Text.Encoding.UTF8.GetBytes(json);

                    // clear everything else that anything might have put in the output stream
                    ms.SetLength(0);

                    // write the new data
                    ms.Write(jsonBytes, 0, jsonBytes.Length);

                    // set parameters on the response object
                    ctx.Response.StatusCode = 200;
                    ctx.Response.ContentLength = jsonBytes.Length;
                    ctx.Response.ContentType = "application/json";
                }
                // In all cases finally write the memory stream's contents back to the actual response stream
                ms.Seek(0, SeekOrigin.Begin);
                await ms.CopyToAsync(outStream);
            }
        }
    }

    public static class AppBuilderExtender
    {
        public static void UseResponseChangeMiddleware(this IAppBuilder app, ResponseChangeMiddlewareOptions options = null )
        {
            if (options == null)
                options = new ResponseChangeMiddlewareOptions();

            app.Use<ResponseChangeMiddleware>(options);
        }
    }

    public class ResponseChangeMiddlewareOptions
    {

    }
}

我已经做了很明显的事情——一整夜的 RAM 测试（一切都很好），并在另一个系统上尝试（它也发生在那里）。

此外，错误并不一致 - 它发生的时间大约有一半。换句话说，通常我可以通过一两个成功的请求，但最终还是会发生错误。

最后，如果我在我的中间件内存流复制之前在我的程序中设置一个断点，然后慢慢地单步执行代码，则永远不会发生错误。这向我表明我必须遇到某种竞争条件，并且它必须与我正在玩 MemoryStreams 的事实有关。

有任何想法吗？

4

1 回答 1

5

天啊。

我不确定改变这是否是正确的做法，但它肯定解决了问题：

await ms.CopyToAsync(outStream);

至

ms.CopyTo(outStream);

我唯一的猜测是，在异步调用完成复制之前，应用程序以某种方式关闭了 MemoryStream，这是有道理的。

于 2016-07-08T22:09:32.480 回答