不在.NET Core中处置流

Question

Consider ASP.NET Core's ResponseBufferingMiddleware:

public class ResponseBufferingMiddleware
{
    private readonly RequestDelegate _next;

    public ResponseBufferingMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext httpContext)
    {
        var originalResponseBody = httpContext.Response.Body;

        // no-op if buffering is already available.
        if (originalResponseBody.CanSeek)
        {
            await _next(httpContext);
            return;
        }

        var originalBufferingFeature = httpContext.Features.Get<IHttpBufferingFeature>();
        var originalSendFileFeature = httpContext.Features.Get<IHttpSendFileFeature>();
        try
        {
            // Shim the response stream
            var bufferStream = new BufferingWriteStream(originalResponseBody);
            httpContext.Response.Body = bufferStream;
            httpContext.Features.Set<IHttpBufferingFeature>(new HttpBufferingFeature(bufferStream, originalBufferingFeature));
            if (originalSendFileFeature != null)
            {
                httpContext.Features.Set<IHttpSendFileFeature>(new SendFileFeatureWrapper(originalSendFileFeature, bufferStream));
            }

            await _next(httpContext);

            // If we're still buffered, set the content-length header and flush the buffer.
            // Only if the content-length header is not already set, and some content was buffered.
            if (!httpContext.Response.HasStarted && bufferStream.CanSeek && bufferStream.Length > 0)
            {
                if (!httpContext.Response.ContentLength.HasValue)
                {
                    httpContext.Response.ContentLength = bufferStream.Length;
                }
                await bufferStream.FlushAsync();
            }
        }
        finally
        {
            // undo everything
            httpContext.Features.Set(originalBufferingFeature);
            httpContext.Features.Set(originalSendFileFeature);
            httpContext.Response.Body = originalResponseBody;
        }
    }
}

Link to actual file: https://github.com/aspnet/BasicMiddleware/blob/dev/src/Microsoft.AspNetCore.Buffering/ResponseBufferingMiddleware.cs

Why is this not a memory leak? They create a new BufferingWriteStream ( https://github.com/aspnet/BasicMiddleware/blob/dev/src/Microsoft.AspNetCore.Buffering/BufferingWriteStream.cs ), but never dispose of it. Does the HTTP Pipeline automatically dispose of streams after a finished request or something?

Answer 1

This stream is just a wrapper around other stream you pass in its constructor ( originalResponseBody in this case). As such - there is no need to dispose it - by itself it does not contain any unmanaged resources it can clear\\release, nor does it contain any other disposable components it should dispose, so there is no reason for it to implement IDisposable , but it inherits from class that already implements it. It just proxies all Stream methods (like Read and so on) to the wrapped stream with some additional logic (buffering).