.NET Core 6.0 自定义异常处理中间件配置

using IPSP.Common;
using Microsoft.IdentityModel.Tokens;
using System.Net;
using System.Text.Json;

namespace IPSP.Middlewares
{
    public static class CutomExceptionHandleMiddlewareExtension
    {
        public static IApplicationBuilder UseCustomExceptionHandleMiddleware(this IApplicationBuilder builder)
        {
            return builder.UseMiddleware<CustomExceptionHandleMiddleware>();
        }
    }
    public class CustomExceptionHandleMiddleware
    {
        private readonly RequestDelegate _next;
        private readonly IWebHostEnvironment _env;
        private readonly ILogger<CustomExceptionHandleMiddleware> _logger;

        public CustomExceptionHandleMiddleware(RequestDelegate next, IWebHostEnvironment env, ILogger<CustomExceptionHandleMiddleware> logger)
        {
            _next = next;
            _env = env;
            _logger = logger;
        }

        public async Task InvokeAsync(HttpContext context)
        {
            string message = string.Empty;
            HttpStatusCode code = HttpStatusCode.InternalServerError;

            ResposeResult result = new ResposeResult(code,message);

            try
            {
                await _next(context);
            }
            catch (SecurityTokenExpiredException exception)
            {
                _logger.LogError(exception,exception.Message);
                SetUnAuthorizeRespose(exception,ref result);
                await WriteToResposeAsync(context,result);
            }
            catch (UnauthorizedAccessException exception)
            {
                _logger.LogError(exception,exception.Message);

                SetUnAuthorizeRespose(exception,ref result);
                await WriteToResposeAsync(context,result);
            }
            catch (Exception exception)
            {
　　　　　　　　　　//asp.net core 引入了 HttpContext.RequestAborted 来监听用户取消请求
                //由用户取消请求触发的异常
                if (context.RequestAborted.IsCancellationRequested && (exception is TaskCanceledException || exception is OperationCanceledException))
                {
                    _logger.LogInformation(exception, exception.Message);
                }
                else
                {
                    _logger.LogError(exception, exception.Message);
                }

                if (_env.IsDevelopment())
                {
                    var dic = new Dictionary<string, string>
                    {
                        ["Exception"] = exception.Message,
                        ["StackTrace"] = exception.StackTrace,
                    };
                    result.Message = JsonSerializer.Serialize(dic);
                }
                else
                {
                    result.Message = message;
                }
                await WriteToResposeAsync(context,result);
            }
        }

        public async Task WriteToResposeAsync(HttpContext context,ResposeResult result)
        {
            if (context.Response.HasStarted)
            {
                throw new InvalidOperationException("The response has already started, the http status code middleware will not be executed.");
            }

            string json = JsonSerializer.Serialize(result);
            context.Response.StatusCode = (int)result.Code;
            context.Response.ContentType = "application/json";
            await context.Response.WriteAsync(json);

        }


        public void SetUnAuthorizeRespose(Exception exception,ref ResposeResult result)
        {
            result.Code = HttpStatusCode.Unauthorized;

            if (_env.IsDevelopment())
            {
                var dic = new Dictionary<string, string>
                {
                    ["Exception"] = exception.Message,
                    ["StackTrace"] = exception.StackTrace
                };

                if (exception is SecurityTokenExpiredException tokenException)
                {
                    dic.Add("Expires",tokenException.Expires.ToString());
                    result.Message = JsonSerializer.Serialize(dic);
                }
            }
        }
    }
}

public class ResposeResult
    {
        public HttpStatusCode Code { get; set; }
        public string Message { get; set; }

        public ResposeResult(HttpStatusCode code, string message="")
        {
            Code = code;
            Message = message;
        }
    }

var app = builder.Build();
//注意请将异常处理中间件放置在请求管道的开始处，这样才能捕获到全局的异常
//使用自定义异常处理中间件
app.UseCustomExceptionHandleMiddleware();

[HttpGet]
        public async Task<IActionResult> UserLogin([FromQuery]LoginModel model)
        {
            User user = new User();
            user.Badge = model.Badge;
            user.Password = model.Password;

            int num = 0;
            int value = 10 / num;

            var result = await _userservice.Login(user.Badge,user.Password);
            if (result != null)
            {
                _logger.LogInformation($"{result.Badge}-{result.CName}在{DateTime.Now.ToString("yyyy-dd-MM HH:mm:ss")}登入了IPSP系统！");
            }
            return Ok(result);
        }