ASP .NET Core Api使用过滤器

简介

过滤器说明

过滤器与中间件很相似，过滤器（Filters）可在管道（pipeline）特定阶段（particular stage）前后执行操作。可以将过滤器视为拦截器（interceptors）。

过滤器级别范围

过滤器有多个级别，分别是：

全局级别过滤器（Global scope），通过Program.cs全局添加Filter
控制器级别过滤器（Controller scope），通过AttributeUsage特性配置
动作级别过滤器（Action scope），通过AttributeUsage特性配置

过滤器类型

Asp.Net Core 过滤器：

IResourceFilter
IAuthorizationFilter
IPageFilter
ExceptionFilterAttribute
ActionFilterAttribute

过滤器类型	接口	对应特性	含义
授权过滤器	IAuthorizationFilter、IAsyncAuthorizationFilter	没有提供特性类	最先执行，用于判断用户是否授权。如果未授权，则直接结束当前请求。这种类型的过滤器实现了 IAsyncAuthorizationFilter 或IAuthorizationFilter 接口。
资源过滤器	IResourceFilter、IAsyncResourceFilter	没有提供特性类	在Authorization过滤器后执行，并在执行其他过滤器（除Authorization过滤器外）之前和之后执行。由于它在Action之前执行，因而可以用来对请求判断，根据条件来决定是否继续执行Action。这种类型过滤器实现了 IAsyncResourceFilter 或 IResourceFilter 接口。
操作过滤器	IActionFilter、IAsyncActionFilter	ActionFilterAttribute	在Action执行的前后执行。与Resource过滤器不一样，它在模型绑定后执行。这种类型的过滤器实现了 IAsyncActionFilter 或 IActionFilter 接口。
页面过滤器	IPageFilter、IAsyncPageFilter	没有提供特性类	页面过滤器是 Razor Pages 等效的操作过滤器
结果过滤器	IResultFilter、IAsyncResultFilter、 IAlwaysRunResultFilter、IAsyncAlwaysRunResultFilter	ResultFilterAttribute	在 IActionResult 执行的前后执行，使用它能够控制Action的执行结果，比如：格式化结果等。需要注意的是，它只有在Action方法成功执行完成后才会运行。这种类型过滤器实现了 IAsyncResultFilter 或 IResultFilter 接口。
异常过滤器	IExceptionFilter、IAsyncExceptionFilter	ExceptionFilterAttribute	异常过滤器用于管理未处理的异常，比如：用于捕获异常。这种类型的过滤器实现了 IAsyncExceptionFilter 或 IExceptionFilter 接口。

不同类型的过滤器在ASP.NET Core中的位置。可以看到不同类型的过滤器在不同阶段起作用。授权过滤器先于其他所有操作，并在任何授权错误时阻止请求。资源过滤器在模型验证和模型绑定请求之前运行，也在我们的请求结果从服务器返回时运行。动作过滤器类型在动作调用之前和之后起作用。此外，如果操作引发异常，则会触发异常过滤器。在管道的末尾，结果过滤器对 IActionResult 最终对象实例进行操作。

ActionFilter

ActionFilterAttribute 拦截器通过重写 OnActionExecuting，来拦截action的请求消息，当执行OnActionExecuting完成以后才真正进入请求的action中，action运行完后又把控制权给了 OnActionExecuted，这个管道机制可以使我们用它来轻松实现权限认证、日志记录，跨域以及很多需要对全局或者部分请求做手脚的的功能。
大概的流程如下：

ActionFilter全称是ActionFilterAttribute，我们根据微软的命名规范可以看出这是一个特性类，看一下它的声明：

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
public abstract class ActionFilterAttribute : Attribute, IActionFilter, IFilterMetadata, IAsyncActionFilter, IAsyncResultFilter, IOrderedFilter, IResultFilter

这是一个允许标注在类和方法上的特性类，允许多个标记，标注之后子类会继承父类的特性。然后，这个类是一个抽象类，所以我们可以通过继承ActionFilterAttribute来编写自己的ActionFilter。

ActionFilter 四个方法

public virtual void OnActionExecuted(ActionExecutedContext context);
public virtual void OnActionExecuting(ActionExecutingContext context);

public virtual void OnResultExecuted(ResultExecutedContext context);
public virtual void OnResultExecuting(ResultExecutingContext context);

上图是这四个方法在一次请求中执行的顺序。在一次请求真正执行之前，想要拦截这个请求，应该使用OnActionExecuting。

为什么单独说这个呢？因为这个方法的出镜率很高，大多数时候都会使用这个方法进行请求过滤。

获取Api请求相关信息

using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Razor.TagHelpers;
using Microsoft.AspNetCore.Mvc.Controllers;
using System.Text;
using System.Text.Json;

namespace WebApplication1
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
    public class ApiFilter : ActionFilterAttribute
    {

        private string ActionArguments { get; set; }
        private readonly ILogger<ApiFilter> _logger;
        private readonly IServiceProvider _serviceProvider;
        public ApiFilter(ILogger<ApiFilter> logger, IServiceProvider serviceProvider)
        {
            _logger = logger;
            _serviceProvider = serviceProvider;
        }

        /// <summary>
        /// 执行方法体之后,返回result前
        /// </summary>
        /// <param name="context"></param>
        public override void OnActionExecuted(ActionExecutedContext context)
        {

            var request = context?.HttpContext?.Request;

            //请求地址
            string url = request.Host + request.Path + request.QueryString;

            var descriptor = (ControllerActionDescriptor)context.ActionDescriptor;
            //获取控制器名称
            var controllerName = descriptor.ControllerName;
            //获取action名称
            var actionName = descriptor.ActionName;
            //获取request参数
            var requestArguments = ActionArguments;
            //请求方式
            string method = request.Method;
            //请求Header
            var headrs = request.Headers;
            //context.HttpContext.Request.Form

            //Response
            var Response = context?.HttpContext?.Response;
            var result = context.Result;
            if (result is JsonResult json)
            {
                var x = json.Value;
                var status = json.StatusCode;
                var content = JsonSerializer.Serialize(x);
            }
            if (result is ViewResult view)
            {
                var status = view.StatusCode;
                var x = view.ViewData;
                var name = view.ViewName;
            }
            if (result is ObjectResult ob)
            {
                var x = ob.Value;
                var status = ob.StatusCode;
                var content = JsonSerializer.Serialize(x);
            }

            base.OnActionExecuted(context);

        }

        /// <summary>
        /// 执行方法体之前
        /// </summary>
        /// <param name="context"></param>
        public override void OnActionExecuting(ActionExecutingContext context)
        {
            try
            {
                if (context.ActionArguments != null && context.ActionArguments.Count > 0)
                {
                    ActionArguments = JsonSerializer.Serialize(context.ActionArguments);
                }
                else
                {
                    ActionArguments = string.Empty;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.StackTrace);
            }

            base.OnActionExecuting(context);
        }

        /// <summary>
        /// 返回result之前
        /// </summary>
        /// <param name="context"></param>
        public override void OnResultExecuting(ResultExecutingContext context)
        {
            base.OnResultExecuting(context);
        }

        /// <summary>
        /// 返回result之后
        /// </summary>
        /// <param name="context"></param>
        public override void OnResultExecuted(ResultExecutedContext context)
        {
            base.OnResultExecuted(context);
        }
    }
}

ActionFilter 记录异常日志

using Microsoft.AspNetCore.Mvc.Filters;
using System.Text.Json;

namespace WebApplication1
{
    public class ExceptionFilter : ActionFilterAttribute
    {
        private string ActionArguments { get; set; }
        private readonly ILogger<ApiFilter> _logger;
        private readonly IServiceProvider _serviceProvider;
        public ExceptionFilter(ILogger<ApiFilter> logger, IServiceProvider serviceProvider)
        {
            _logger = logger;
            _serviceProvider = serviceProvider;
        }

        /// <summary>
        /// 执行方法体之后,返回result前
        /// </summary>
        /// <param name="context"></param>
        public override void OnActionExecuted(ActionExecutedContext context)
        {
            if (context.Exception != null)
            {
                LoggerError(context, context.Exception);
            }

            base.OnActionExecuted(context);
        }

        /// <summary>
        /// 执行方法体之前
        /// </summary>
        /// <param name="context"></param>
        public override void OnActionExecuting(ActionExecutingContext context)
        {
            try
            {
                if (context.ActionArguments != null && context.ActionArguments.Count > 0)
                {
                    ActionArguments = JsonSerializer.Serialize(context.ActionArguments);
                }
                else
                {
                    ActionArguments = string.Empty;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.StackTrace);
            }

            base.OnActionExecuting(context);
        }


        private void LoggerError(ActionExecutedContext context, Exception exception)
        {
            try
            {
                string url = context.HttpContext.Request.Host + context.HttpContext.Request.Path + context.HttpContext.Request.QueryString;
                string method = context.HttpContext.Request.Method;
                string message = $"\n" + $"地址：{url} \n " +
                $"方式：{method} \n " +
                $"参数：{ActionArguments}\n " +
                $"错误描述：{context.Exception.Message}\n " +
                $"错误堆栈：{context.Exception.StackTrace}\n ";
                if (exception.InnerException != null)
                {
                    message += "\n InnerException异常Message：" + exception.InnerException.Message;
                    message += "\n InnerException异常StackTrace：" + exception.InnerException.StackTrace;
                }
                _logger.LogError(message);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.StackTrace);
            }
        }
    }
}

ExceptionFilter 记录异常日志

using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.EntityFrameworkCore;
using System;
using System.Net;
using System.Text.Json;

namespace WebApplication1
{
    public class ExceptionFilte2r : ExceptionFilterAttribute
    {
        public override void OnException(ExceptionContext context)
        {

            Exception ex = context.Exception;
            string url = context.HttpContext.Request.Host + context.HttpContext.Request.Path + context.HttpContext.Request.QueryString;
            string method = context.HttpContext.Request.Method;
            string message = $"\n " + $"地址：{url} \n " +
            $"方式：{method} \n " +
            $"错误描述：{ex.Message}\n " +
            $"错误堆栈：{ex.StackTrace}\n ";

            //while (ex.InnerException != null) { ex = ex.InnerException; }
            if (ex.InnerException != null)
            {
                message += "\n InnerException异常Message：" + ex.InnerException.Message;
                message += "\n InnerException异常StackTrace：" + ex.InnerException.StackTrace;
            }
            context.HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
            context.Result = new ObjectResult(message);

            // 表明异常已处理，客户端可得到正常返回
            context.ExceptionHandled = true;

            base.OnException(context);
        }
    }
}

全局添加过滤器

在Program.cs添加Filter

builder.Services.Configure<MvcOptions>(opts => opts.Filters.Add<ExceptionFilter>());

builder.Services.AddControllersWithViews(options =>
{
    //options.Filters.Add(new ApiFilter(null,null));
    options.Filters.Add<ApiFilter>();
});

//或者
builder.Services.Configure<MvcOptions>(opts => opts.Filters.Add<ExceptionFilter>());

参考文档

https://www.cnblogs.com/cqpanda/p/16907950.html

ASP .NET Core Api使用过滤器

简介

过滤器说明

过滤器级别范围

过滤器类型

ActionFilter

ActionFilter 四个方法

获取Api请求相关信息

ActionFilter 记录异常日志

ExceptionFilter 记录异常日志

全局添加过滤器

参考文档

ollama使用

Window 安装 Python 失败 0x80070643，发生严重错误

TiDB Vector 太香啦：以图搜图初体验！

《最新出炉》系列入门篇-Python+Playwright自动化测试-41-录制视频

Fiddler修改返回數據

.Net 程序版本向前兼容

ASP .NET Core MemoryCache緩存

Windows10內置Linux子系統（WSL）設置服務自啓

Docker Compose 安裝及使用

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結