ASP.NET CORE之中间件-自定义异常中间件

参考资料： https://docs.microsoft.com/zh-cn/aspnet/core/fundamentals/middleware/?view=aspnetcore-3.1

1、一般Asp.Net Core 创建项目后 StartUp文件中存在 StartUp、ConfigureServices 、Configure 函数或方法

2、中间件一般在Configure中配置或启用

不多说了,直接操作

一、创建项目（.NetCore 3.1）

建议创建API项目便于后续测试验证，因为本人只是Demo创建一个空API显得更为整洁

创建完成后StartUp类

public class Startup
    {
        // This method gets called by the runtime. Use this method to add services  to the container.
        // For more information on how to configure your application, visit  https://go.microsoft.com/fwlink/?LinkID=398940
        public void ConfigureServices(IServiceCollection services)
        {
        }
        // This method gets called by the runtime. Use this method to configure the  HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            app.UseRouting();
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapGet("/", async context =>
                {
                    await context.Response.WriteAsync("Hello World!");
                });
            });
        }
    }

2、创建扩展类、中间件、结果类

Extension

 public static class ApplicationBuilderExtensions
    {
        public static IApplicationBuilder UseExceptionHandle(this  IApplicationBuilder app)
        {
            app.UseMiddleware<ExceptionHandleMiddleware>();//UseMiddleware添加中间件
            return app;
        }
    }

Middleware

public  class ExceptionHandleMiddleware
    {
        private readonly RequestDelegate _next;
        private readonly ILogger _logger;
        public  ExceptionHandleMiddleware( RequestDelegate next,   ILogger<ExceptionHandleMiddleware> logger)
        {
            _next = next;
            _logger = logger;
        }
        public async Task InvokeAsync(HttpContext httpContext)
        {
            try
            {
                await _next(httpContext);
            }
            catch (Exception ex)
            {
                await HandleExceptionAsync(httpContext, ex);
            }
        }
        private Task HandleExceptionAsync(HttpContext context, Exception exception)
        {
            context.Response.ContentType = "application/json";
            context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
            var error =  exception.ToString();
            _logger.LogError(error);
            return  context.Response.WriteAsync(JsonConvert.SerializeObject(ResultModel.Failed(error),  new JsonSerializerSettings
            {
                ContractResolver = new CamelCasePropertyNamesContractResolver()
            }));
        }
    }

IResult

/// <summary>
    /// 返回结果模型接口
    /// </summary>
    public interface IResultModel
    {
        /// <summary>
        /// 是否成功
        /// </summary>
        [JsonIgnore]
        bool Successful { get; }
        /// <summary>
        /// 错误
        /// </summary>
        string Msg { get; }
    }
    /// <summary>
    /// 返回结果模型泛型接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IResultModel<T> : IResultModel
    {
        /// <summary>
        /// 返回数据
        /// </summary>
        T Data { get; }
    }

Result

/// <summary>
    /// 返回结果
    /// </summary>
    public class ResultModel<T> : IResultModel<T>
    {
        /// <summary>
        /// 处理是否成功
        /// </summary>
        [JsonIgnore]
        public bool Successful { get; private set; }
        /// <summary>
        /// 错误信息
        /// </summary>
        public string Msg { get; private set; }
        /// <summary>
        /// 状态码
        /// </summary>
        public int Code => Successful ? 1 : 0;
        /// <summary>
        /// 返回数据
        /// </summary>
        public T Data { get; private set; }
        /// <summary>
        /// 成功
        /// </summary>
        /// <param name="data">数据</param>
        /// <param name="msg">说明</param>
        public ResultModel<T> Success(T data = default, string msg = "success")
        {
            Successful = true;
            Data = data;
            Msg = msg;
            return this;
        }
        /// <summary>
        /// 失败
        /// </summary>
        /// <param name="msg">说明</param>
        public ResultModel<T> Failed(string msg = "failed")
        {
            Successful = false;
            Msg = msg;
            return this;
        }
    }
    /// <summary>
    /// 返回结果
    /// </summary>
    public static class ResultModel
    {
        /// <summary>
        /// 成功
        /// </summary>
        /// <param name="data">返回数据</param>
        /// <returns></returns>
        public static IResultModel Success<T>(T data = default(T))
        {
            return new ResultModel<T>().Success(data);
        }
        /// <summary>
        /// 成功
        /// </summary>
        /// <returns></returns>
        public static IResultModel Success()
        {
            return Success<string>();
        }
        /// <summary>
        /// 失败
        /// </summary>
        /// <param name="error">错误信息</param>
        /// <returns></returns>
        public static IResultModel Failed<T>(string error = null)
        {
            return new ResultModel<T>().Failed(error ?? "failed");
        }
        /// <summary>
        /// 失败
        /// </summary>
        /// <returns></returns>
        public static IResultModel Failed(string error = null)
        {
            return Failed<string>(error);
        }
        /// <summary>
        /// 根据布尔值返回结果
        /// </summary>
        /// <param name="success"></param>
        /// <returns></returns>
        public static IResultModel Result<T>(bool success)
        {
            return success ? Success<T>() : Failed<T>();
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="success"></param>
        /// <returns></returns>
        public static IResultModel Result(bool success)
        {
            return success ? Success() : Failed();
        }
        /// <summary>
        /// 数据已存在
        /// </summary>
        /// <returns></returns>
        public static IResultModel HasExists => Failed("数据已存在");
        /// <summary>
        /// 数据不存在
        /// </summary>
        public static IResultModel NotExists => Failed("数据不存在");
    }