.NET Core FilterAttribute中有没有办法获取请求体？

Question

我的请求样本

http://localhost:8065/api/note
POST
content-type:application/json
request body: { "id" : "1234", "title" : "test", "status" : "draft"}

响应应该是

{ "msg" : "ok", "code" : 1}

行动

public async Task<IActionResult> Post([FromBody]NoteModel model)

---

为了自动记录每个请求，我创建了一个属性来完成这项工作。该属性如下所示：（来自 Microsoft Docs）

public class SampleActionFilterAttribute : TypeFilterAttribute
{
    public SampleActionFilterAttribute():base(typeof(SampleActionFilterImpl))
    {
    }

    private class SampleActionFilterImpl : IActionFilter
    {
        private readonly ILogger _logger;
        public SampleActionFilterImpl(ILoggerFactory loggerFactory)
        {
            _logger = loggerFactory.CreateLogger<SampleActionFilterAttribute>();
        }

        public void OnActionExecuting(ActionExecutingContext context)
        {

        }

        public void OnActionExecuted(ActionExecutedContext context)
        {
            _logger.LogDebug("[path]" + context.HttpContext.Request.Path);
            _logger.LogDebug("[method]" + context.HttpContext.Request.Method);
            _logger.LogDebug("[body]"); //log request body, expectation: { "id" : "1234", "title" : "test", "status" : "draft"}
            _logger.LogDebug("[statuscode]" + context.HttpContext.Response.StatusCode);
            _logger.LogDebug("[response]"); //log response
        }
    }
}

我尝试使用streamReader来获取请求正文，但只得到空字符串。

StreamReader reader = new StreamReader(context.HttpContext.Request.Body);
string text = reader.ReadToEnd();

是因为主体是由[fromBody]从控制器读取的，所以流不能被读取两次吗？如果是这样，我该如何在

OnActionExecuted

方法中获取请求正文和响应？

---

更新：

我刚刚将 Set 的代码复制到我的项目中，但不起作用。这是调试gif

Answer 1

根据这个“在中间件中记录/读取请求正文的最佳方式”线程，以下内容应该有效：

// using Microsoft.AspNetCore.Http.Internal;

public class SampleActionFilterAttribute : TypeFilterAttribute
{
    ... 

    public void OnActionExecuting(ActionExecutedContext context)
    {
        // read body before MVC action execution
        string bodyData = ReadBodyAsString(context.HttpContext.Request);
    }

    private string ReadBodyAsString(HttpRequest request)
    {
        var initialBody = request.Body; // Workaround

        try
        {
            request.EnableRewind();

            using (StreamReader reader = new StreamReader(request.Body))
            {
                string text = reader.ReadToEnd();
                return text;
            }
        }
        finally
        {
            // Workaround so MVC action will be able to read body as well
            request.Body = initialBody; 
        }

        return string.Empty;
    }
 }

在读取请求正文两次SO帖子

中也描述了类似的方法

---

更新：如果在中间件中使用，而不是在操作过滤器中使用，则

ReadBodyAsString

中的上述方法将起作用。不同之处在于，当调用动作过滤器时（即使对于

OnActionExecuting

），主体流已被读取并且

[FromBody] model

已被填充。

好消息是，可以使用

context.ActionArguments["<model_name>"]

直接在动作过滤器中获取模型。对于你的情况：

public void OnActionExecuted(ActionExecutedContext context)
{
   var model = context.ActionArguments["model"] as NoteModel;
}

Answer 2

以下代码片段对我有用，仅在出现任何异常时才记录请求。（.Net Core 3.1）

{

public class ExceptionFilter : IActionFilter
{
    private ConcurrentDictionary<string, string> requests = new ConcurrentDictionary<string, string>();

    public void OnActionExecuted(ActionExecutedContext context)
    {
        if (context.Exception != null)

        {
            StringBuilder parameters = new StringBuilder();

            _logger.LogError("Error while executing action:" + context.ActionDescriptor.DisplayName);

            string errRequest;
            if(requests.TryGetValue(context.HttpContext.TraceIdentifier,out errRequest))
            {
                _logger.LogError(errRequest);
            }

            _logger.LogError(context.Exception);

            context.Result = new ObjectResult("Error!!!")
            {
                StatusCode = 500,
            };
            context.ExceptionHandled = true;
        }

        string req;
            requests.Remove(context.HttpContext.TraceIdentifier, out req);


    }

    public void OnActionExecuting(ActionExecutingContext context)
    {
        StringBuilder sb = new StringBuilder();
        foreach (var arg in context.ActionArguments)
        {

            sb.Append(arg.Key.ToString() + ":" + Newtonsoft.Json.JsonConvert.SerializeObject(arg.Value) + "\n");

        }
        requests.TryAdd(context.HttpContext.TraceIdentifier, sb.ToString());
    }


}

}

Answer 3

    in .net core 3.1, I usually use this approach to handle this scenario
    
    1- Create Async Filter Attribute
    
    public class MyFilter : IAsyncAuthorizationFilter
        {
            private string _errorMessage = UserAccessErrorMessages.NO_ACCESS;
            public async Task OnAuthorizationAsync(AuthorizationFilterContext context)
            {
                string requestBody = await ReadBodyAsString(context.HttpContext.Request);
                var reportFiltration = JsonConvert.DeserializeObject<YourModel>(requestBody);
                var _myService = (IMyService)context.HttpContext.RequestServices.GetService(typeof(IMyService));
                    if (!hasAccess)
                    {
                        context.Result = new UnauthorizedObjectResult(_errorMessage);
                    }
            }
    
            private async Task<string> ReadBodyAsString(Microsoft.AspNetCore.Http.HttpRequest request)
            {
                var initialBody = request.Body; // Workaround
    
                try
                {
                    //request.EnableRewind();
    
                    using (StreamReader reader = new StreamReader(request.Body))
                    {
                        string text = await reader.ReadToEndAsync();
                        return text;
                    }
                }
                finally
                {
                    // Workaround so MVC action will be able to read body as well
                    request.Body = initialBody;
                }
            }
        }
2- Create Your Custom Attribute
public class MyAttribute : TypeFilterAttribute, IAllowAnonymous
    {
        public MyAttribute () : base(typeof(MyFilter))
        {

        }
    }

3-使用你的过滤器

    [HttpPost]
    [ActionName("MyAction")]
    [MyAttribute]
    public async Task<IActionResult> PostData([FromBody]MyModel model)

Answer 4

如果您在控制器中使用 IActionResult 并且需要 .NET 对象，则可以编写如下过滤器：

public class SampleFilter : IActionFilter
{
    public void OnActionExecuted(ActionExecutedContext context)
    {
        if (context.Result is ObjectResult)
        {
            var objResult = (ObjectResult)context.Result;
        }
    }

    public void OnActionExecuting(ActionExecutingContext context)
    {

    }
}

当它到达 OnActionExecuted 时，ObjectResult 任务已经完成，因此您可以提取值。您还可以使用 objResult.StatusCode 获取 StatusCode。

在控制器中，return Ok(...)实际上创建了一个OkObjectResult等

如果你特别想要序列化结果，那么Set的答案更有效。

Answer 5

创建一个类来映射请求json

object obj = context.ActionArguments["query"]; 
if (obj != null) {
   APIBaseResponse bc = JsonConvert.DeserializeObject<APIBaseResponse>(JsonConvert.SerializeObject(obj));
   No= bc.No;
   Code = bc.Code; 
}

------------------------------------------------------------------------