asp.net core ActionExecutedContext 获取Request.Body内容

实体类：

public class ApiActionDescriptorModel:ICloneable
   {
        
       public string ActionName { get; set; } 
 
       public string ControllerName { get; set; } 
 
       public ApiParameterDescriptorModel[] Parameters { get; set; } 
 
       public ApiReturnAttributeModel[] apiReturnAttributes { get; set; } 
 
       public string RequestIp { get; set; } 
 
       public string HttpMethod { get; set; } 
 
       public string RequestPort { get; set; }
 
       public long ExecutTime { get; set; } 
 
       public string Operator { get; set; } 
 
       public DateTime OperaTime { get; set; } 
 
       public string RequestBody { get; set; } 
 
       public string QueryString { get; set; }
        
       public string ResposeBody { get; set; } 
 
       public int ResposeStatusCode { get; set; } 
 
       public string UserId { get; set; }
 
       public object Clone()
       {
           return new ApiActionDescriptorModel
           {
               ActionName = this.ActionName,
               RequestIp = this.RequestIp,
               HttpMethod = this.HttpMethod,
               RequestPort = this.RequestPort,
               ExecutTime = this.ExecutTime,
               Parameters = this.Parameters.Select(t => (ApiParameterDescriptorModel)t.Clone()).ToArray()
           };
       }
   }

　　过滤器：

public class ExceptionFilter : IExceptionFilter
    {
        [Import]
        private ILoggerHelper loggerHelper { get; set; }
 
        public ExceptionFilter(IoC ioc) 
        {
            ioc.Compose(this);
        }
 
        public void OnException(ExceptionContext context)
        {
            if (context.ExceptionHandled == false)
            {
                var jsonobj = Dr.Soc.Common.Helpers.JsonResult.Error(context.Exception.Message);
                context.Result = new JsonResult(jsonobj);
            }
            loggerHelper.Error($"全局捕获异常：" + context.Exception.ToString()+"====="+
                "入参参数："+ GetExceptionRequestBody(context)+context?.HttpContext?.Request?.QueryString);
             
            context.ExceptionHandled = true;
        }
 
        public Task OnExceptionAsync(ExceptionContext context)
        {
            OnException(context);
            return Task.CompletedTask;
        }
 
        private string GetExceptionRequestBody(ExceptionContext context)
        {
            string requestBody = "";
            if (context != null)
            {
                var request = context?.HttpContext?.Request;
                if (request != null)
                {
                    request.Body.Position = 0;
                    StreamReader stream = new StreamReader(request.Body);
                    requestBody = stream.ReadToEnd();
                    request.Body.Position = 0;
                }
            }
            return requestBody;
        }
 
    }

public class ActionFilter : IActionFilter
   {
       private Stopwatch timer;
 
       [Import]
       private IAduitService aduitService { get; set; }
 
       public ActionFilter(IoC ioc)
       {
           ioc.Compose(this);
       }
 
       public void OnActionExecuting(ActionExecutingContext context)
       {
           this.timer = new Stopwatch();
           this.timer.Start();
       }
 
       public void OnActionExecuted(ActionExecutedContext context)
       {
           this.timer.Stop();
           aduitService.HandleApiAction(GetActionDescriptor(context));
       }
 
       private ApiActionDescriptorModel GetActionDescriptor(ActionExecutedContext context)
       {
           ApiActionDescriptorModel descriptor = new ApiActionDescriptorModel();
   
           var userInfo= ((System.Security.Claims.ClaimsIdentity)context.HttpContext.User.Identity).Claims?.ToList();
           if (context != null)
           {
               descriptor.ActionName = ((ControllerActionDescriptor)context.ActionDescriptor)?.ActionName;
               descriptor.ControllerName = ((ControllerActionDescriptor)context.ActionDescriptor)?.ControllerName;
               descriptor.RequestIp = context.HttpContext.Request.Host.Host.ToString();
               descriptor.RequestPort = context.HttpContext.Request.Host.Port.ToString();
               descriptor.HttpMethod = context.HttpContext.Request.Method.ToString();
               descriptor.ExecutTime = this.timer.ElapsedMilliseconds;
               descriptor.Operator = userInfo?.Where(t => t.Type == "UserName")?.FirstOrDefault()?.Value;
               descriptor.UserId = userInfo?.Where(t => t.Type == "UserId")?.FirstOrDefault()?.Value;
               descriptor.OperaTime = DateTime.Now;
               descriptor.RequestBody = ReadActionExcutedRequestBody(context);
               descriptor.QueryString = context.HttpContext.Request?.QueryString.ToString();
               descriptor.ResposeBody = GetActionExcutedResponseBody(context);
               descriptor.ResposeStatusCode = context.HttpContext.Response.StatusCode;
           }
 
           return descriptor;
       }
 
       private string ReadActionExcutedRequestBody(ActionExecutedContext context)
       {
           string requestBody = "";
           if (context != null)
           {
               var request = context.HttpContext.Request;
               request.Body.Position = 0;
               StreamReader stream = new StreamReader(request.Body);
               requestBody = stream.ReadToEnd();
               request.Body.Position = 0;
           }
           return requestBody;
       }
 
       private string GetActionExcutedResponseBody(ActionExecutedContext context)
       {
           string responseBody = "";
           if (context.Result != null)
           {
               if (context.Result is ObjectResult)
                   responseBody = JsonConvert.SerializeObject(((ObjectResult)context.Result).Value);
               if (context.Result is JsonResult)
                   responseBody = JsonConvert.SerializeObject(((JsonResult)context.Result).Value);
           }
           return responseBody;
       }
   }

在startup中注册：

app.Use(next => new RequestDelegate(
                async context =>
                {
                    context.Request.EnableBuffering();
                    await next(context);
                }
                ));

　　就可以在请求之后获取到请求体了。

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

public async Task<bool> HandleApiAction(ApiActionDescriptorModel apiActionDescriptorModel)
        {
            bool result = false;
            var cacheAuditRule = auditRuleLoader.GetAllAuditRule();
            try
            {
                if (cacheAuditRule == null || cacheAuditRule.Count == 0) return result;
 
                if (string.IsNullOrEmpty(apiActionDescriptorModel?.RequestBody)
                || string.IsNullOrEmpty(apiActionDescriptorModel?.ActionName)
                || string.IsNullOrEmpty(apiActionDescriptorModel?.ControllerName)
                || string.IsNullOrEmpty(apiActionDescriptorModel?.HttpMethod)) return result;
 
                List<AuditModel> list = HandleApiAction(apiActionDescriptorModel, cacheAuditRule);
 
                if (list == null || list.Count == 0) return result;
 
                result = await auditDataAccessor.BatchAddAudit(list.Adapt<List<AuditDao>>()).ConfigureAwait(false);
                return result;
            }
            catch (Exception ex)
            {
                loggerHelper.Error(apiActionDescriptorModel.ControllerName + apiActionDescriptorModel.ActionName + "插入审计失败，失败原因：" + ex.ToString());
                return result;
            }
        }
 
        private List<AuditModel> HandleApiAction(ApiActionDescriptorModel apiActionDescriptorModel, List<AuditRuleModel> auditRuleModels)
        {
            int apiEnum = (int)EnumHelper.GetValue(typeof(HttpMethodEnum), apiActionDescriptorModel.HttpMethod?.ToLower());
 
            var auditRuleModel = auditRuleModels.Where(t => t.ControllerName == apiActionDescriptorModel.ControllerName
             && t.ActionName == apiActionDescriptorModel.ActionName
             && t.HttpMethod == apiEnum)?.FirstOrDefault();
 
            List<AuditModel> list = new List<AuditModel>();
            if (auditRuleModel == null) return list;
 
            if (!string.IsNullOrEmpty(auditRuleModel.AuditRuleDescr))
            {
                var audits = GetAudits(apiActionDescriptorModel, auditRuleModel);
 
                if (audits != null && audits.Count > 0)
                    list = GetAudits(apiActionDescriptorModel, auditRuleModel, audits);
            }
 
            return list;
        }
 
        private List<AuditModel> GetAudits(ApiActionDescriptorModel apiActionDescriptorModel, AuditRuleModel auditRuleModel, List<string> audits)
        {
            List<AuditModel> auditModels = new List<AuditModel>();
            int responseCode = GetResponseCode(apiActionDescriptorModel?.ResposeBody);
            for (int i = 0; i < audits.Count; i++)
            {
                AuditModel auditModel = new AuditModel();
                auditModel.UserName = apiActionDescriptorModel.Operator;
                auditModel.AddTime = apiActionDescriptorModel.OperaTime;
                auditModel.Ip = apiActionDescriptorModel.RequestIp.Replace("localhost", "127.0.0.1");
                auditModel.ResponseCode = responseCode;
                auditModel.ModelType = auditRuleModel.ModelType;
                auditModel.Type = EnumHelper.Parse<OperateType>(auditRuleModel.OperateType);
                auditModel.IncidenceLevel = EnumHelper.Parse<IncidenceLevel>(auditRuleModel.IncidenceLevel);
                auditModel.Detail = audits[i];
                auditModel.UserId = apiActionDescriptorModel.UserId;
                auditModel.UserName = apiActionDescriptorModel.Operator;
 
                auditModels.Add(auditModel);
            }
            return auditModels;
        }
 
        private List<string> GetAudits(ApiActionDescriptorModel apiActionDescriptorModel, AuditRuleModel auditRuleModel)
        {
            var jsonDics = GetKeyValues(apiActionDescriptorModel.RequestBody);
            var urlDics = GetKeyValues(apiActionDescriptorModel.QueryString);
 
            foreach (var item in urlDics)
            {
                if (item != null && item.Count > 0)
                {
                    foreach (var keyValue in item)
                        jsonDics.ForEach(t => t.Add(keyValue.Key, keyValue.Value));
                }
            }
 
            List<string> audits = new List<string>();
 
            foreach (var item in jsonDics)
            {
                var ruleStr = auditRuleModel.AuditRuleDescr;
                string[] rules = RegularHelper.FindByRegexRemoveRegexs(ruleStr, "【\\${.*?}】", "[【】\\${}]+");
                if (rules.Length > 0)
                {
                    for (int i = 0; i < rules.Length; i++)
                    {
                        if (!item.Keys.Contains(rules[i])) continue;
 
                        string value = item[rules[i]];
                        if (rules[i] == auditRuleModel.AssetIdMappingField)
                            value = assetAccountLoader.GetAssetCacheByCode(value).Name;
 
                        ruleStr = ruleStr.Replace("${" + rules[i] + "}", value);
                    }
                }
 
                audits.Add(ruleStr);
            }
            return audits;
        }
 
        private List<Dictionary<string, string>> GetKeyValues(string txt)
        {
            List<Dictionary<string, string>> dics = new List<Dictionary<string, string>>();
 
            if (JsonHelper.StringIsJson(txt))
            {
                string text = RegularHelper.FindFirstByRegex(txt, @"^\[.*?\]$");
 
                List<JObject> jObjects = string.IsNullOrEmpty(text)
                    ? new List<JObject>() { JsonConvert.DeserializeObject<JObject>(txt) }
                    : JsonConvert.DeserializeObject<List<JObject>>(txt);
 
                foreach (var item in jObjects)
                    dics.Add(item.Properties().ToDictionary(x => x.Name, y => y.Value.ToString()));
            }
            else
            {
                NameValueCollection collection = HttpUtility.ParseQueryString(txt);
                var dic = new Dictionary<string, string>();
                foreach (var item in collection.AllKeys)
                    dic.Add(item, collection[item]);
 
                dics.Add(dic);
            }
            return dics;
        }
 
        private static int GetResponseCode(string resposeBody)
        {
            int responseCode = -1;
            int.TryParse(RegularHelper.FindContentBetweenTwoRegex(resposeBody, "code\":", ","), out responseCode);
            return responseCode;
        }
 
        private List<AuditModel> HandleIsJsonActionToAudit(ApiActionDescriptorModel apiActionDescriptorModel, AuditRuleModel auditRuleModel)
        {
            string text = RegularHelper.FindFirstByRegex(apiActionDescriptorModel.RequestBody, @"^\[.*?\]$");
 
            List<JObject> jObjects = null;
            if (!string.IsNullOrEmpty(text))
                jObjects = JsonConvert.DeserializeObject<List<JObject>>(apiActionDescriptorModel.RequestBody);
            else
                jObjects = new List<JObject>() { JsonConvert.DeserializeObject<JObject>(apiActionDescriptorModel.RequestBody) };
 
            string[] rules = RegularHelper.SplitByRegex(auditRuleModel.AuditRuleDescr, "【.*?】");
 
            List<AuditModel> list = null;
 
            for (int i = 0; i < jObjects.Count; i++)
            {
                list = new List<AuditModel>(){
                    new AuditModel()
                    {
                        UserName=apiActionDescriptorModel.Operator,
                        ModelType=auditRuleModel.ModelType,
                        Type =EnumHelper.Parse<OperateType>(auditRuleModel.OperateType),
                        IncidenceLevel =EnumHelper.Parse<IncidenceLevel>(auditRuleModel.IncidenceLevel),
                        UserId=apiActionDescriptorModel.UserId,
                        Detail = GetAuditDetailByRuleRule(jObjects[i], rules).ToString(),
                        AddTime = apiActionDescriptorModel.OperaTime,
                        Ip = apiActionDescriptorModel.RequestIp.Replace("localhost","127.0.0.1"),
                        ResponseCode=GetResponseCode(apiActionDescriptorModel?.ResposeBody),
                    }
                };
            }
 
            return list;
        }
 
        private List<AuditModel> HandleNotJsonActionToAduit(ApiActionDescriptorModel apiActionDescriptorModel, AuditRuleModel auditRuleModel)
        {
            string[] rules = RegularHelper.SplitByRegex(auditRuleModel.AuditRuleDescr, "【.*?】");
 
            List<AuditModel> list = null;
            if (rules.Length >= 2)
            {
                list = new List<AuditModel>(){
                    new AuditModel()
                    {
                         UserName=apiActionDescriptorModel.Operator,
                         ModelType=auditRuleModel.ModelType,
                         Type =EnumHelper.Parse<OperateType>(auditRuleModel.OperateType),
                         IncidenceLevel =EnumHelper.Parse<IncidenceLevel>(auditRuleModel.IncidenceLevel),
                         Detail = GetAuditDetailByRuleRule(apiActionDescriptorModel.RequestBody,rules).ToString(),
                         AddTime = apiActionDescriptorModel.OperaTime,
                         Ip = apiActionDescriptorModel.RequestIp.Replace("localhost","127.0.0.1"),
                         ResponseCode=GetResponseCode(apiActionDescriptorModel?.ResposeBody),
                    }
                };
            }
            return list;
        }
 
        private StringBuilder GetAuditDetailByRuleRule(string text, string[] rules)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append(rules[0]);
 
            for (int i = 1; i < rules.Length; i++)
                sb.Append(
                    RegularHelper.RegexReplace(
                    rules[i],
                    "【.*?】",
                    "【" + RegularHelper.FindContentBetweenTwoRegex(
                        text, "[\\?&]" + RegularHelper.FindContentBetweenTwoRegex(rules[i], @"【\${", "}】") + "=", "(&|$)") + "】"
                        ));
 
            return sb;
        }
 
        private StringBuilder GetAuditDetailByRuleRule(JObject jObject, string[] rules)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append(rules[0]);
            for (int i = 1; i < rules.Length; i++)
            {
                try
                {
                    sb.Append(
                        RegularHelper.RegexReplace(rules[i],
                        "【.*?】",
                    "【" + jObject[RegularHelper.FindContentBetweenTwoRegex(rules[i], @"【\${", "}】")].ToString() + "】"
                    ));
                }
                catch (Exception ex)
                {
                    loggerHelper.Error("在" + rules[i] + "查找失败,具体原因：" + ex.ToString());
                    throw;
                }
            }
 
            return sb;
        }

public static string[] FindByRegexRemoveRegexs(string html, string strReg, string remReg)
       {
           string[] strs = FindByRegex(html, strReg);
           List<string> result = new List<string>();
           if (strs.Length > 0)
           {
               for (int i = 0; i < strs.Length; i++)
                   result.Add(RemoveByRegex(strs[i], remReg));
           }
           return result.ToArray();
       }