Error Handling Middleware

BusinessException.cs

/// <summary>
    /// Classe que controla o tratamento de exceções de regras de negócio.
    /// </summary>
    [Serializable]
    public class BusinessException : Exception
    {
        /// <summary>
        /// Define um código para a exception;
        /// </summary>
        public int Code { get; set; }

        /// <summary>
        /// Define se a mensagem é de erro, alerta, sucesso ou atenção.
        /// </summary>
        public MessageType MessageType { get; set; }

        #region Construtor

        public BusinessException(int code, string message) : this(code, message, null) { }
        public BusinessException(int code, string message, Exception inner) : base(message, inner)
        {
            this.Code = code;
        }

        public BusinessException(string message) : this((int)ReturnCode.BusinessException, message, MessageType.Error) { }
        public BusinessException(string message, MessageType MessageType) : this(message, MessageType, null) { }
        public BusinessException(string message, MessageType MessageType, Exception inner) : base(message, inner)
        {
            this.MessageType = MessageType;
        }

        public BusinessException(int code, string message, MessageType MessageType) : base(message)
        {
            this.Code = code;
            this.MessageType = MessageType;
        }

        public BusinessException(int code, string message, MessageType MessageType, Exception inner) : base(message, inner)
        {
            this.Code = code;
            this.MessageType = MessageType;
        }

        public BusinessException(string message, Exception inner) : base(message, inner) { }

        public BusinessException()
        {
            this.Code = (int)ReturnCode.BusinessException;
            this.MessageType = MessageType.Error;
        }
        protected BusinessException(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
        }
        #endregion Construtor
    }

ErrorMidleware.cs

public class ErrorHandlingMiddleware
    {
        private readonly RequestDelegate _next;

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

        public async Task Invoke(HttpContext context)
        {
            try
            {
                await _next(context);
            }
            catch (Exception ex)
            {
                await HandleExceptionAsync(context, ex);
            }
        }

        private static Task HandleExceptionAsync(HttpContext context, Exception exception)
        {
            IResponseMessage response;
            switch (exception)
            {
                case BusinessException b:
                    response =
                        ResponseMessage.MessageResult(
                            exception: b
                        );
                    context.Response.StatusCode = 452;
                    break;
                case NotFoundException b:
                    response =
                        ResponseMessage.MessageResult(
                            exception: b
                        );
                    context.Response.StatusCode = 404;
                    break;
                case InternalServerException b:
                    response =
                        ResponseMessage.MessageResult(
                            exception: b
                        );
                    context.Response.StatusCode = 500;
                    break;
                case BadRequestException b:
                    response =
                        ResponseMessage.MessageResult(
                            exception: b
                        );
                    context.Response.StatusCode = 400;
                    break;
                case { } e:
                    response =
                        ResponseMessage.MessageResult(
                            exception: e
                        );
                    break;
                default:
                    response = new ResponseMessage(
                        new {guidError = Guid.NewGuid(), error = exception.Message}
                    )
                    {
                        Messages = new List<MessageCode>
                        {
                            new MessageCode((int) ReturnCode.Exception,
                                "Ocorreu um erro inesperado na execução desta requisição", "Error")
                        },
                        Success = false
                    };
                    context.Response.StatusCode = (int) HttpStatusCode.InternalServerError;
                    break;
            }

            var result = JsonConvert.SerializeObject(response);
            context.Response.ContentType = "application/json";
            return context.Response.WriteAsync(result);
        }
    }

IResponseMessage.cs

public interface IResponseMessage<T>
    {
        bool Success { get; set; }

        IList<MessageCode> Messages { get; set; }

        T Response { get; set; }

        string DataResponseType { get; set; }
    }

    public interface IResponseMessage : IResponseMessage<object>
    {

    }

Startup.cs

app.UseMiddleware(typeof(ErrorHandlingMiddleware));