Middleware for .net core custom specification responses

Middleware for .net core custom specification responses

In this article, we will introduce how to use middleware in .NET Core to customize canonical responses so that uniform formats and error messages can be returned when API calls. Middleware is a software component that can execute logic in the request and response pipeline, which can modify, intercept or process the request or response. We’ll use a simple example to demonstrate how to create and use middleware for custom canonical responses.

First, we need to create a class to represent the format of the canonical response. This class can contain the following attributes:

• Code: The status code of the response, for example, 200 means success, 400 means client error, 500 means server error, etc.
• Message: The response message, such as “OK” means success, “Bad Request” means client error, “Internal Server Error” means server error, etc.
• Data: The response data can be any type of object, such as user information, product list, order details, etc.

The code for this class is as follows:

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)
     {
     }
 }
 

Middleware

Next, we need to create a middleware class to implement the logic of the custom specification response. This class needs to have the following characteristics:

• Receives a parameter of type RequestDelegate, indicating the next middleware or terminal handler.
• Implement an InvokeAsync method that receives a parameter of type HttpContext, indicating the context of the current request.
• In the InvokeAsync method, use await next(context) to call the next middleware or terminal handler and get the response it returns.
• In the InvokeAsync method, construct an ApiResponse object according to the status code and content of the response, and serialize it into JSON format.
• In the InvokeAsync method, modify the content type of the response to application/json, and write ApiResponse in JSON format to the response body middle.
• GetStatusCodeMessage()Give information according to the response status
• GetResponseData()Get the response returned by it

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