net 5.0 中间件获取入参（Request）、出参（response）

中间件方法

////操作日志中间件
public class HttpContextMiddleware
    {
        public readonly RequestDelegate _next;
        public readonly string _serviceName;
        public HttpContextMiddleware(
            RequestDelegate next,
            string serviceName
            )
        {
            _next = next;
            _serviceName = serviceName;
        }

        public async Task Invoke(HttpContext context)
        {
            try
            {
                DateTime StartTime = DateTime.Now;
                //过滤非Api的请求
                var request = context.Request;
                if (request.Path.Value.Contains("api"))
                {
                    var requestIp = GetRemoteIp(context);
                    xxx info = new xxx()
                    {
                        remoteip = requestIp,
                        path = request.Path,
                        requesttype = request.Method,
                        scheme = request.Scheme,
                        createtime = DateTime.Now,
                    };

                    // 获取请求body内容
                    if (request.Method.ToLower().Equals("post") || request.Method.ToLower().Equals("put"))
                    {
                        //启用读取request
                        request.EnableBuffering();

                        //设置当前流中的位置为起点
                        request.Body.Seek(0, SeekOrigin.Begin);

                        //把请求body流转换成字符串
                        info.requestdata = await new StreamReader(request.Body).ReadToEndAsync();

                        request.Body.Seek(0, SeekOrigin.Begin);
                    }
                    else if (request.Method.ToLower().Equals("get") || request.Method.ToLower().Equals("delete"))
                    {
                        info.requestdata = request.QueryString.Value;
                    }

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

                        //返回结果                        
                        var response = context.Response;

                        info.actiontime = (DateTime.Now - StartTime).TotalSeconds;//执行时间差
                        //设置当前流中的位置为起点
                        responseBody.Seek(0, SeekOrigin.Begin);

                        var responesInfo = await new StreamReader(responseBody).ReadToEndAsync();

                        //设置当前流中的位置为起点
                        responseBody.Seek(0, SeekOrigin.Begin);

                        // 编码转换，解决中文乱码
                        responesInfo = Regex.Unescape(responesInfo);
                       
                        //返回参数
                        info.resultdata = responesInfo;
                        //返回代码
                        info.statuscode = response.StatusCode.ToString();

                        await responseBody.CopyToAsync(originalBodyStream);
                        context.Response.Body = originalBodyStream;
                    }
                    // 操作日志持久化缓存到mongo
                     xxxxxxxx
                }
                else
                {
                    await _next(context);
                }
            }
            catch (Exception ex)
            {
                await HandleExceptionAsync(context, -1, "未知错误");
            }

        }




        /// <summary>
        /// 根据文件类型获取数据编码类型
        /// </summary>
        /// <param name="contentType">文件类型</param>
        /// <returns></returns>
        private Encoding GetEncoding(string contentType)
        {
            var mediaType = contentType == null ? default(MediaType) : new MediaType(contentType);
            var encoding = mediaType.Encoding;
            if (encoding == null)
            {
                encoding = Encoding.UTF8;
            }
            return encoding;
        }

        /// <summary>
        /// 获取客户端Ip
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public static string GetRemoteIp(HttpContext context)
        {
            var remoteIp = context.Request.Headers["X-Forwarded-For"].FirstOrDefault();
            if (string.IsNullOrEmpty(remoteIp))
            {
                remoteIp = context.Connection.RemoteIpAddress.ToString();
                if (remoteIp == "::1")
                {
                    remoteIp = "127.0.0.1";
                }
                return remoteIp;
            }
            return remoteIp;
        }

        /// <summary>
        /// 返回请求信息
        /// </summary>
        /// <param name="context">上下文</param>
        /// <param name="code">返回编码</param>
        /// <param name="info">返回信息</param>
        /// <returns></returns>
        private static Task HandleExceptionAsync(HttpContext context, int code, string info)
        {
            object operateStatus = new
            {
                code = code,
                info = info
            };
            var result = JsonConvert.SerializeObject(operateStatus);
            context.Response.ContentType = "application/json;charset=utf-8";
            return context.Response.WriteAsync(result);
        }
    }

返回参数（context.Response.Body）乱码问题

  public IServiceProvider ConfigureServices(IServiceCollection services)
        {

            services.AddControllersWithViews().AddJsonOptions(options =>
            {
                options.JsonSerializerOptions.Encoder = JavaScriptEncoder.Create(UnicodeRanges.All);
            });
         }

 

中间件扩展方法

/// <summary>
    /// 中间件扩展方法
    /// </summary>
    public static class MiddlewareExtensions
    {
        /// <summary>
        /// 操作日志中间件
        /// </summary>
        /// <param name="builder"></param>
        /// <param name="serviceName">服务名称</param>
        /// <returns></returns>
        public static IApplicationBuilder UseRequetOperateMiddleware(this IApplicationBuilder builder, string serviceName)
        {
            if (builder == null)
            {
                throw new ArgumentNullException(nameof(builder));
            }
            return builder.UseMiddleware<HttpContextMiddleware>(serviceName);
        }

    }

 

中间件使用

  public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            app.UseRequetOperateMiddleware("energyinformation");
         }