Common Interceptors and Filters in ASP.NET Core

There are readers suggesting to use app.UseExceptionHandler(); for global exception interception.
https://learn.microsoft.com/en-us/aspnet/core/fundamentals/error-handling?view=aspnetcore-9.0

The main difference lies in the middleware position when the request arrives. For the entire web lifecycle, it is recommended to use app.UseExceptionHandler();.

The focus is mainly on handling exceptions within MVC requests.

Global Exception Interceptor:

    /// <summary>
    /// Web global exception filter, handling runtime unhandled exceptions that occur in the web
    /// </summary>
    public class WebGlobalExceptionFilter : IAsyncExceptionFilter
    {
        private readonly ILogger _logger;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="loggerFactory"></param>
        public WebGlobalExceptionFilter(ILoggerFactory loggerFactory)
        {
            _logger = loggerFactory.CreateLogger<WebGlobalExceptionFilter>();
        }

        // JSON serialization configuration
        private static readonly JsonSerializerOptions JsonSetting = new JsonSerializerOptions()
        {
            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            WriteIndented = true
        };

        /// <summary>
        /// Exception handling
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public async Task OnExceptionAsync(ExceptionContext context)
        {
            // Unhandled exception
            if (!context.ExceptionHandled)
            {
                _logger.LogCritical(context.Exception, context.ActionDescriptor.DisplayName);
                var response = new ResponseJsonResultModel<object>()
                {
                    Code = (int)HttpStateCode.InternalServerError,
                    Msg = ResponseCode.SystemErrorValue,
                };

                context.Result = new ContentResult
                {
                    Content = JsonSerializer.Serialize(response, JsonSetting),
                    StatusCode = (int)HttpStateCode.InternalServerError,
                    ContentType = "application/json; charset=utf-8"
                };

                context.ExceptionHandled = true;
            }
            else
            {
                _logger.LogError(context.Exception, context.ActionDescriptor.DisplayName);
            }

            await Task.CompletedTask;
        }
    }
	

Resource Interceptor:

    /// <summary>
    /// Request filter validation, such as missing parameters, incorrect metadata types like 400, 405, 415, etc.
    /// </summary>
    public partial class ResourceFilter : IResourceFilter
    {
        private readonly ILogger _logger;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="loggerFactory"></param>
        public ResourceFilter(ILoggerFactory loggerFactory)
        {
            _logger = loggerFactory.CreateLogger<WebGlobalExceptionFilter>();
        }


        /// <summary>
        /// During request
        /// </summary>
        /// <param name="context"></param>
        public void OnResourceExecuting(ResourceExecutingContext context)
        {
        }

        /// <summary>
        /// After request
        /// </summary>
        /// <param name="context"></param>
        public void OnResourceExecuted(ResourceExecutedContext context)
        {
            // Validation passed
            if (context.ModelState.IsValid)
            {
                return;
            }

            int count = context.ModelState.Count;
            ValidationErrors[] errors = new ValidationErrors[count];
            int i = 0;
            foreach (var item in context.ModelState)
            {
                errors[i] = new ValidationErrors
                {
                    Member = item.Key,
                    Messages = item.Value.Errors?.Select(x => x.ErrorMessage).ToArray()
                };
                i++;
            }

            // Response message
            var result = new ResponseJsonResultModel<ValidationErrors[]>()
            {
                Code = (int)HttpStateCode.BadRequest,
                Msg = "Request format is incorrect",
                Data = errors
            };

            _logger.LogDebug(System.Text.Json.JsonSerializer.Serialize(result));

            var objectResult = new BadRequestObjectResult(result);
            objectResult.StatusCode = (int)HttpStateCode.BadRequest;
            context.Result = objectResult;
        }
    }
	

Unified Model Validator:

    /// <summary>
    /// Unified Action model validation filter
    /// </summary>
    public class ActionInvalidModelFilter : IAsyncActionFilter
    {
        /// <summary>
        /// Interceptor
        /// </summary>
        /// <param name="context"></param>
        /// <param name="next"></param>
        /// <returns></returns>
        public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
        {
            // Validation passed
            if (context.ModelState.IsValid)
            {
                await next();
                return;
            }

            int count = context.ModelState.Count;
            ValidationErrors[] errors = new ValidationErrors[count];
            int i = 0;
            foreach (var item in context.ModelState)
            {
                errors[i] = new ValidationErrors
                {
                    Member = item.Key,
                    Messages = item.Value.Errors?.Select(x => x.ErrorMessage).ToArray()
                };
                i++;
            }

            // Response message
            var result = new ResponseJsonResultModel<ValidationErrors[]>()
            {
                Code = (int)HttpStateCode.BadRequest,
                Msg = "Request parameters are incorrect",
                Data = errors
            };

            var objectResult = new BadRequestObjectResult(result);
            objectResult.StatusCode = (int)HttpStateCode.BadRequest;
            context.Result = objectResult;
            await Task.CompletedTask;
        }
    }

When performing dependency injection, add the following:

            // Filters
            services.AddControllers(options =>
            {
                options.Filters.Add<WebGlobalExceptionFilter>();
                options.Filters.Add<ActionInvalidModelFilter>();
                options.Filters.Add<ResourceFilter>();
            });