.NET Core Web API - 如何从 ActionResult 获取响应信息

Question

I have a WebAPI Core endpoint method where I am using a in-house library (RequestLogManager) to save the request and response data from and incoming request.

Because I want to log the response code and body , I am storing the ActionResult in a variable that is returned at the end of the method (instead of returning from multiple locations in the method). Example:

    // This is a contrived method to illustrate the issue.
    
    [Route("test/actionresult/{testParam:int}")]
    [HttpGet]
    public async Task<ActionResult> GetTestActionResult(int testParam)
    {
        ActionResult actionResult = Ok(); // Default

        // Log Incoming Request
        int requestlogid = await RequestLogManager.LogIncomingRequestAsync("API - GetTestActionResult", Request);

        switch (testParam)
        {
            case 204:
                actionResult = NoContent();
                break;

            case 404:
                actionResult = NotFound();
                break;

            case 500:
                actionResult = StatusCode(StatusCodes.Status500InternalServerError, "An Error Occurred!");
                break;

            default:
                break;
        }

        // Log Outgoing Response
        RequestLogManager.LogResponseForRequestNoWait(requestlogid, ??? ResponseBody ???, ??? ResponseCode ???);

        return actionResult;
    }

At the end of my method, how can I get the value for the response code and body from ActionResult to log?

• I tried using Response.Body and Response.StatusCode, but those are always "" and 200 (I presume because I'm using ActionResult and not actually creating an HttpResponse).
• I tried casting ActionResult to ObjectResult - ObjectResult does have those in properties StatusCode and Value - but that results in an error message: Unable to cast object of type 'Microsoft.AspNetCore.Mvc.NoContentResult' to type 'Microsoft.AspNetCore.Mvc.ObjectResult'

Answer 1

Middleware are the way to go to handle request and response logging. You can your custom middleware and they can be hooked to the HTTP pipeline and you can perform the logging within the middleware implementations. This approach helps you do it globally.

Creating middleware for your intercepting your requests and responses

// Request Logging middleware
public class RequestLoggingMiddleware
{
    private RequestDelegate _next;
    public RequestLoggingMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        // Logic to log your request. Can be accessed via "context.Request"
        await _next.Invoke(context);
    }
}

// Response Logging Middleware
public class ResponseLoggingMiddleware
{
    private RequestDelegate _next;
    public ResponseLoggingMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        // observe the Invoke() method being called first
        await _next.Invoke(context)
        // This is where your logging logic goes. For eg., you can capture 404 as below
        if(context.Response.StatusCode == 404)
        {
            // log the 404 and do whatever you want to do on a 404 here.
        }
    }
}

Hooking up the middleware to HTTP pipeline

This is pretty straightforward and done with the below statements of code.

// Within the Configure() method of Startup.cs
app.UseMiddleware<ResponseLoggingMiddleware>();
app.UseMiddleware<RequestLoggingMiddleware>();

The order in which you are hooking up the middleware matters here. More information on middleware ordering and middleware in general here

Update:

Creating custom attribute to handle logging at endpoint level

public class LoggingAttribute : Attribute, IActionFilter
{
    public void OnActionExecuted(ActionExecutedContext context)
    {
        // This method is called just right after the completion of the 
        // execution of the action method. Status Code can be obtained as shown below
        // response logging based on status code goes here.
        var result = context.Result;
        var response = context.HttpContext.Response.StatusCode;
    }

    public void OnActionExecuting(ActionExecutingContext context)
    {
        // This method is called before the action method is invoked.
        // Access the request using context.HttpContext.Request
        // and include the logging logic where
        var request = context.HttpContext.Request;            
    }
}

This attribute can now be added to your action method inside your controller wherever required as shown below.

[HttpGet]
[LoggingAttribute]
public ActionResult<IEnumerable<string>> Get()
{
    // ...other code
}