.net core 自定义规范响应的中间件

在本文中，我们将介绍如何使用 .NET Core 中的中间件来自定义规范响应，以便在 API 调用时返回统一的格式和错误信息。中间件是一种可以在请求和响应管道中执行逻辑的软件组件，它可以对请求或响应进行修改、拦截或处理。我们将使用一个简单的示例来演示如何创建和使用自定义规范响应的中间件。

首先，我们需要创建一个类来表示规范响应的格式，这个类可以包含以下属性：

• Code：响应的状态码，例如 200 表示成功，400 表示客户端错误，500 表示服务器错误等。
• Message：响应的消息，例如 "OK" 表示成功，"Bad Request" 表示客户端错误，"Internal Server Error" 表示服务器错误等。
• Data：响应的数据，可以是任意类型的对象，例如用户信息、产品列表、订单详情等。

这个类的代码如下：

public class ApiResponse
{
    public bool Success { get; set; }
    public string Message { get; set; }
    public object Data { get; set; }

    public ApiResponse(bool success, string message, object data)
    {
        Success = success;
        Message = message;
        Data = data;
    }

    public ApiResponse(bool success, string message)
        : this(success, message, null)
    {
    }

    public ApiResponse(bool success)
        : this(success, null, null)
    {
    }
}

中间件

接下来，我们需要创建一个中间件类来实现自定义规范响应的逻辑，这个类需要有以下特点：

• 接收一个 RequestDelegate 类型的参数，表示下一个中间件或终端处理程序。
• 实现一个 InvokeAsync 方法，接收一个 HttpContext 类型的参数，表示当前请求的上下文。
• 在 InvokeAsync 方法中，使用 await next(context) 来调用下一个中间件或终端处理程序，并获取其返回的响应。
• 在 InvokeAsync 方法中，根据响应的状态码和内容来构造一个 ApiResponse对象，并将其序列化为 JSON 格式。
• 在 InvokeAsync 方法中，修改响应的内容类型为 application/json，并将 JSON 格式的 ApiResponse写入到响应体中。
• GetStatusCodeMessage()根据响应状态给出信息
• GetResponseData()获取其返回的响应

CustomResponseMiddleware

public class CustomResponseMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        var originalBodyStream = context.Response.Body;

        using (var responseBody = new MemoryStream())
        {
            context.Response.Body = responseBody;

            await _next(context);

            if (context.Response.StatusCode >= 400 && context.Response.StatusCode <= 599)
            {
                context.Response.ContentType = "application/json";

                var response = new ApiResponse
                {
                    Success = false,
                    Message = GetStatusCodeMessage(context.Response.StatusCode),
                    Data = await GetResponseData(context.Response)
                };

                var jsonResponse = JsonConvert.SerializeObject(response);
                await context.Response.WriteAsync(jsonResponse, Encoding.UTF8);
            }
            else
            {
                context.Response.ContentType = "application/json";

                var response = new ApiResponse
                {
                    Success = true,
                    Message = GetStatusCodeMessage(context.Response.StatusCode),
                    Data = await GetResponseData(context.Response)
                };

                var jsonResponse = JsonConvert.SerializeObject(response);
                await context.Response.WriteAsync(jsonResponse, Encoding.UTF8);
            }

            await responseBody.CopyToAsync(originalBodyStream);
        }
    }
}

GetStatusCodeMessage()

 private static string GetStatusCodeMessage(int statusCode)
    {
        switch (statusCode)
        {
            case 200:
                return "OK";
            case 201:
                return "Created";
            case 204:
                return "No Content";
            case 400:
                return "Bad Request";
            case 401:
                return "Unauthorized";
            case 403:
                return "Forbidden";
            case 404:
                return "Not Found";
            case 500:
                return "Internal Server Error";
            default:
                return "Unknown Status Code";
        }
    }

GetResponseData()

private async Task<object> GetResponseData(HttpResponse response)
    {
        var body = await new StreamReader(response.Body).ReadToEndAsync();
        response.Body.Seek(0, SeekOrigin.Begin);

        try
        {
            return JsonConvert.DeserializeObject(body);
        }
        catch (JsonReaderException)
        {
            return new { Message = body };
        }
    }

在上面的示例中，我们创建了一个名为 CustomResponseMiddleware 的中间件。该中间件拦截每个响应，并根据需要修改响应格式。具体来说，如果响应的状态码为 4xx 或5xx，则中间件将返回一个包含错误消息和数据的 ApiResponse 对象；否则，中间件将返回一个包含成功消息和数据的 ApiResponse 对象。

常用类

定义常用的类可以帮助我们标准化 ASP.NET Core 应用程序中的响应格式，提高代码重用性，并使前端更加轻松地处理所有响应。

除了 ApiResponse 类之外，还可以定义其他常用类，如 ApiError 类、ApiResponse 泛型类等，以满足不同的需求。例如，ApiError 类可以用于标准化应用程序中的错误响应格式，ApiResponse 泛型类可以用于在响应中包含更具体的数据类型。

下面是 ApiError 类的示例代码：

public class ApiError
{
    public int StatusCode { get; set; }
    public string Message { get; set; }

    public override string ToString()
    {
        return JsonConvert.SerializeObject(this);
    }
}

ApiError 类包含两个属性：StatusCode 和 Message。StatusCode 属性指示错误的状态码，Message 属性包含有关错误的消息。

使用 ApiError 类可以帮助我们标准化应用程序中的错误响应格式。例如，在某些情况下，我们可能需要返回一个包含单个错误消息的响应，而在其他情况下，我们可能需要返回一个包含多个错误消息的响应。通过使用 ApiError 类，我们可以在应用程序中统一处理这些情况，并返回一个标准的错误响应格式。

结论

通过使用 ASP.NET Core 中间件和常用类，我们可以自定义 ASP.NET Core 应用程序中的响应格式，并标准化应用程序中的响应格式。这可以提高代码重用性，并使前端更加轻松地处理所有响应。在开发 ASP.NET Core 应用程序时，我们应该始终考虑使用中间件和常用类来提高代码的可读性、可维护性和可重用性。

原文链接：https://www.cnblogs.com/ke210/p/17298562.html