asp.net 异常过滤 filter middleware 中间件

异常过滤

Middleware过滤异常

API\Middlewares\ExceptionMiddleware.cs

using System.Net;
using API.Contracts;

namespace API.Middlewares;

public class ExceptionMiddleware
{
    private readonly RequestDelegate _next;

    public ExceptionMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            context.Response.ContentType = "application/json";
            context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
            var error = new Error
            {
                StatusCode = context.Response.StatusCode.ToString(),
                Message = $"Exception Middleware: {ex.Message}",
            };
            await context.Response.WriteAsync(error.ToString());
        }
    }
}

API\Extensions\ApplicationBuilderExtensions.cs

using API.Middlewares;
using Microsoft.AspNetCore.Builder;

namespace API.Extensions;

public static class ApplicationBuilderExtensions
{
    public static IApplicationBuilder UseExceptionMiddleware(this IApplicationBuilder app)
    {
        return app.UseMiddleware<ExceptionMiddleware>();
    }
}

API\Program.cs

var app = builder.Build();
// exception handling middleware
app.UseExceptionMiddleware();
// ...
app.Run();

Filter过滤异常

API\Filters\ExceptionFilter.cs

using API.Contracts;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using System.Net;

namespace API.Filters;

public class ExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext context)
    {

        var error = new Error
        {
            StatusCode = HttpStatusCode.InternalServerError.ToString(),
            Message = $"Exception Filter: {context.Exception.Message}",
        };

        context.Result = new JsonResult(error) 
        { 
            StatusCode = (int) HttpStatusCode.InternalServerError 
        };
    }
}

API\Program.cs

var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
// builder.Services.AddControllers();

builder.Services.AddControllers(config =>
{
    // global exception handling filter
    config.Filters.Add(typeof(ExceptionFilter));
});
app.Run();

other

API\Contracts\Error.cs

using System.Text.Json;

namespace API.Contracts;

public class Error
{
    public string? StatusCode { get; set; }
    public string? Message { get; set; }

    public override string ToString()
    {
        return JsonSerializer.Serialize(this);
    }
}

API\Program.cs

using API.Extensions;
using API.Filters;

namespace API
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);

            // Add services to the container.
            builder.Services.AddControllers();

            // builder.Services.AddControllers(config =>
            // {
            //     // global exception handling filter
            //     config.Filters.Add(typeof(ExceptionFilter));
            // });


            // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
            builder.Services.AddEndpointsApiExplorer();
            builder.Services.AddSwaggerGen();

            var app = builder.Build();
            // exception handling middleware
            app.UseExceptionMiddleware();

            if (app.Environment.IsDevelopment())
            {
                app.UseSwagger();
                app.UseSwaggerUI();
            }

            app.UseHttpsRedirection();

            app.UseAuthorization();

            app.MapControllers();

            app.Run();
        }
    }
}