Read ASP.NET Core Response.Body | Getting The Request Body And Response Body In ASP.NET Core middleware

Logging Request Body and Response Body in ASP.NET Core API

Let's create a custom middleware to log the request body and response body in our ASP.NET Core API. We'll use the OrderController as an example.

1. Custom Middleware:

First, we'll create a custom middleware to intercept the request and response streams:

using System.IO;
    using System.Text;
    using System.Threading.Tasks;
    using Microsoft.AspNetCore.Http;

    public class LoggingMiddleware
    {
        private readonly RequestDelegate _next;

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

        public async Task Invoke(HttpContext context)
        {
            // Log the request body
            string requestBody = await ReadRequestBody(context.Request);
            Console.WriteLine("Request Body: " + requestBody);

            // Replace the response stream with a custom stream
            var originalResponseBody = context.Response.Body;
            var responseBodyStream = new MemoryStream();
            context.Response.Body = responseBodyStream;

            // Invoke the next middleware in the pipeline
            await _next(context);

            // Log the response body
            responseBodyStream.Seek(0, SeekOrigin.Begin);
            string responseBody = await new StreamReader(responseBodyStream, Encoding.UTF8).ReadToEndAsync();
            Console.WriteLine("Response Body: " + responseBody);

            // Copy the response back to the original stream and reset the position
            responseBodyStream.Seek(0, SeekOrigin.Begin);
            await responseBodyStream.CopyToAsync(originalResponseBody);
            context.Response.Body = originalResponseBody;
        }

        private async Task<string> ReadRequestBody(HttpRequest request)
        {
            request.EnableBuffering();
            using var reader = new StreamReader(request.Body, Encoding.UTF8, true, 1024, true);
            var requestBody = await reader.ReadToEndAsync();
            request.Body.Seek(0, SeekOrigin.Begin);
            return requestBody;
        }
    }

2. Register Middleware:

Next, we'll register our custom middleware in the application startup:

 public void Configure(IApplicationBuilder app)
    {
        // Add the custom middleware to the pipeline
        app.UseMiddleware<LoggingMiddleware>();

        
    }

With this middleware , we'll be able to log the request body and response body for each request to our ASP.NET Core API.

Rreading the response body in ASP.NET Core 6, we use the HttpContext.Response.Body property, this property provides access to the response body stream, which we can read to obtain the response content. 

we first obtain the response body stream using HttpContext.Response.Body. We then save the current position of the response body stream to be able to reset it later. We seek to the beginning of the response body stream and read it as a string using a StreamReader with UTF-8 encoding and then finally, we reset the position of the response body stream to its original position before returning the response body string.

    using Microsoft.AspNetCore.Http;
    using System.IO;
    using System.Text;

    public async Task ReadResponseBody(HttpContext context)
    {
        // Get the response body stream
        Stream responseBody = context.Response.Body;

        // Save the current position of the response body stream
        long originalPosition = responseBody.Position;

        // Seek to the beginning of the response body stream
        responseBody.Seek(0, SeekOrigin.Begin);

        // Read the response body stream as a string
        using var reader = new StreamReader(responseBody, Encoding.UTF8);
        string responseBodyString = await reader.ReadToEndAsync();

        // Reset the position of the response body stream to its original position
        responseBody.Seek(originalPosition, SeekOrigin.Begin);

        return responseBodyString;
    }
    

    using Microsoft.AspNetCore.Http;
    using System.IO;
    using System.Text;
    using System.Threading.Tasks;

    public class ResponseReadingMiddleware
    {
        private readonly RequestDelegate _next;

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

        public async Task InvokeAsync(HttpContext context)
        {
            // Capture the original response body stream
            var originalBodyStream = context.Response.Body;

            // Create a new memory stream to capture the response body
            using (var responseBody = new MemoryStream())
            {
                // Replace the original response body with the memory stream
                context.Response.Body = responseBody;

                // Call the next middleware in the pipeline
                await _next(context);

                // Reset the response body position and read the response
                responseBody.Seek(0, SeekOrigin.Begin);
                string responseBodyString = await new StreamReader(responseBody, Encoding.UTF8).ReadToEndAsync();

                // Log or process the response body as needed
                Console.WriteLine("Response Body: " + responseBodyString);

                // Copy the response body back to the original stream
                responseBody.Seek(0, SeekOrigin.Begin);
                await responseBody.CopyToAsync(originalBodyStream);
            }
        }
    }
    

    public void Configure(IApplicationBuilder app)
    {
        // Add the custom middleware to the pipeline
        app.UseMiddleware<ResponseReadingMiddleware>();

        
    }