经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » ASP.net » 查看文章
在 Net Core 开发中如何解决 Cannot access a disposed object 这个问题
来源：cnblogs　　作者：可均可可　　时间：2023/6/2 10:52:47　　对本文有异议

一、简介
　　　　Net Core跨平台项目开发多了，总会遇到各种各样的问题，我就遇到了一个这样的问题，不能访问 Cannot access a disposed object 错误，经过自己多方努力，查阅资料，终于找到了解决办法，引发这个问题的原因大多数是多次读取请求Body流造成的，需要换一种获取请求Body流方法，不能使用StreamRreader方式，使用Body.CopyTo(ms)方法。

        　   我使用的环境：Visual Studio 2022
　　　　开发语言：C#
　　　　开发框架：Asp.Net Core Mvc
　　　　DotNet版本：Net 6.0

　　　　遇到问题是好事，说明自己还有不足，那就解决它，时间长了，技术和知识也就积累了。其实解决方法不难，话不多，直接上解决方案。

二、解决方案的具体实现。
　　　解决方法很简单，不需要做过多解释，直接找个配置和编码就可以了，我贴完整源码，是便于以后查阅，不喜勿喷。

　　  总共三步：红色字体写好了操作步骤（说明一下，红色字体是要解决方法，其他不要关注，把整个代码贴出来，是为了以后查阅）

  1. using Microsoft.AspNetCore.Authentication.Cookies;
  2. using Microsoft.AspNetCore.Mvc.Razor;
  3. using Microsoft.AspNetCore.Server.Kestrel.Core;
  4. using OpticalTrap.Framework.DataAccessors;
  5. using OpticalTrap.Web.Facade.Extensions.Filters;
  6. using OpticalTrap.Web.Facade.Utilities;
  7. using OpticalTrap.Web.ServiceManager;
  9. var builder = WebApplication.CreateBuilder(args);
  11. builder.Services.AddControllersWithViews(option =>
  12. {
  13.     option.Filters.Add(typeof(GlobalAuthorizationFilterAttribute));
  14.     option.Filters.Add(typeof(GlobalOperationLogFilterAttribute));
  15. }).AddXmlSerializerFormatters();
  17. #region 第一步：配置可以同步请求读取流数据
  19. builder.Services.Configure<KestrelServerOptions>(k => k.AllowSynchronousIO = true)
  20.     .Configure<IISServerOptions>(k => k.AllowSynchronousIO = true);
  22. #endregion
  23.  
  24. #region 配置日志
  26. builder.Logging.AddLog4Net("ConfigFiles/log4net.config");
  28. #endregion
  29.  
  30. #region 配置 Session
  32. builder.Services.AddSession();
  34. #endregion
  35.  
  36. #region 配置数据库
  38. builder.Services.AddTransientSqlSugar(builder.Configuration["ConnectionStrings:DefaultConnectionString"]);
  40. #endregion
  41.  
  42. #region 配置区域
  44. builder.Services.Configure<RazorViewEngineOptions>(option =>
  45. {
  46.     option.AreaViewLocationFormats.Clear();
  47.     option.AreaViewLocationFormats.Add("/Areas/{2}/Views/{1}/{0}.cshtml");
  48.     option.AreaViewLocationFormats.Add("/Areas/{2}/Views/Shared/{0}.cshtml");
  49.     option.AreaViewLocationFormats.Add("/Views/Shared/{0}.cshtml");
  50. });
  52. #endregion
  53.  
  54. #region 配置服务实例
  56. builder.Services.AddBusinessServices();
  57. builder.Services.AddUtilityServices();
  58. builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
  59. builder.Services.AddSingleton<SessionCacheObjectProvider>();
  60. builder.Services.AddTransient<AuthorizedDataGridGeneratorWrapper>();
  61. builder.Services.AddSingleton<PageNumberGenerator>();
  63. #endregion
  64.  
  65. #region 认证设置
  67. builder.Services.AddAuthentication(option =>
  68. {
  69.     option.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme;
  70.     option.DefaultChallengeScheme = CookieAuthenticationDefaults.AuthenticationScheme;
  71.     option.DefaultSignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
  72.     option.DefaultForbidScheme = CookieAuthenticationDefaults.AuthenticationScheme;
  73.     option.DefaultSignOutScheme = CookieAuthenticationDefaults.AuthenticationScheme;
  74. }).AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, options =>
  75. {
  76.     options.LoginPath = "/Validation/Index";
  77.     options.LogoutPath = "/Validation/Logout";
  78.     options.AccessDeniedPath = "/Validation/Index";
  79.     options.Cookie.HttpOnly = true;
  80.     options.ClaimsIssuer = "Cookie";
  81. });
  83. #endregion
  84.  
  85. var app = builder.Build();
  87. //第二步：启用倒带, 在发生异常时, 可以通过过滤器获取post参数
  88. app.Use((context, next) =>
  89. {
  90.     context.Request.EnableBuffering();
  91.     return next(context);
  92. });
  94. if (app.Environment.IsProduction())
  95. {
  96.     app.UseStatusCodePagesWithReExecute("/ErrorHandler/HttpStatusCode", "?statusCode={0}");
  97.     app.UseExceptionHandler("/ErrorHandler/ExceptionHandler");
  98. }
  99. else
  100. {
  101.     app.UseDeveloperExceptionPage();
  102. }
  104. app.UseStaticFiles();
  106. app.UseSession();
  107. app.UseRouting();
  109. app.UseAuthentication();
  110. app.UseAuthorization();
  112. app.MapControllerRoute("defaultAreaRoute", "{area:exists}/{controller=Home}/{action=Index}/{id?}");
  114. app.MapControllerRoute("defaultRoute", "{controller=Home}/{action=Index}/{id?}");
  116. app.Run();
 
        我写了一个过滤器（实现日志功能），实现的是IActionFilter 过滤器，在过滤器中，获取Post请求Body的Context使用下面方式获取强调（强调，关注红色字体，其他无关，这是我写的日志功能，贴全部代码，便于以后查阅，不喜勿喷）
  1.   1 using Microsoft.AspNetCore.Mvc.Filters;
  2.   2 using OpticalTrap.Framework.Loggings;
  3.   3 using OpticalTrap.Web.ConstProvider;
  4.   4 using OpticalTrap.Web.Contracts;
  5.   5 using OpticalTrap.Web.Facade.Controllers;
  6.   6 using OpticalTrap.Web.Models;
  7.   7 using System.Reflection;
  8.   8 using System.Security.Claims;
  9.   9 using System.Text;
  10.  10 
  11.  11 namespace OpticalTrap.Web.Facade.Extensions.Filters
  12.  12 {
  13.  13     /// <summary>
  14.  14     /// 该类型定义了全局处理操作日志的过滤器，该类型是密封类型。
  15.  15     /// </summary>
  16.  16     public sealed class GlobalOperationLogFilterAttribute : Attribute, IActionFilter, IAsyncActionFilter
  17.  17     {
  18.  18         #region 实例字段
  19.  19 
  20.  20         private readonly IOperationLogService _operationLogService;
  21.  21         private readonly IServiceProvider _serviceProvider;
  22.  22 
  23.  23         #endregion
  24.  24 
  25.  25         #region 构造函数
  26.  26 
  27.  27         /// <summary>
  28.  28         /// 初始化该类型的新实例。
  29.  29         /// </summary>
  30.  30         /// <param name="operationLogService">需要注入的操作日志服务实例。</param>
  31.  31         /// <param name="serviceProvider">需要注入的服务提供器。</param>
  32.  32         public GlobalOperationLogFilterAttribute(IOperationLogService operationLogService, IServiceProvider serviceProvider)
  33.  33         {
  34.  34             _operationLogService = operationLogService;
  35.  35             _serviceProvider = serviceProvider;
  36.  36         }
  37.  37 
  38.  38         #endregion
  39.  39 
  40.  40         #region 操作日志的同步方法
  41.  41 
  42.  42         /// <summary>
  43.  43         /// 在标注方法执行之前执行该方法。
  44.  44         /// </summary>
  45.  45         /// <param name="context">方法执行前的上下文。</param>
  46.  46         public async void OnActionExecuting(ActionExecutingContext context)
  47.  47         {
  48.  48             if (context.Controller.GetType() != typeof(ErrorHandlerController))
  49.  49             {
  50.  50                 if (context.ActionDescriptor.EndpointMetadata.Any(c => c.GetType() == typeof(RequiredLogAttribute)))
  51.  51                 {
  52.  52                     #region 核心处理
  53.  53 
  54.  54                     var controllerType = context.Controller.GetType();
  55.  55                     var controllerName = controllerType.Name;
  56.  56                     var currentMethodName = context.ActionDescriptor.RouteValues["action"]!;
  57.  57 
  58.  58                     string? loginName = string.Empty;
  59.  59                     var claimKeysProvider = _serviceProvider.GetService<ClaimKeysConstProvider>();
  60.  60                     if (claimKeysProvider != null)
  61.  61                     {
  62.  62                         loginName = context.HttpContext.User.FindFirstValue(claimKeysProvider.ClaimStoreUserNameKey);
  63.  63                     }
  64.  64 
  65.  65                     var currentDateTime = DateTime.Now;
  66.  66                     var methodType = context.HttpContext.Request.Method;
  67.  67                     string parameterResult = string.Empty;
  68.  68                     //获取 Get 方法传递的参数，包括查询参数（queryString的值）和Id（{controller=home}/{action=index}/{id?}）值，路由配置中的Id。
  69.  69                     if (string.Compare(methodType, "get", true) == 0)
  70.  70                     {
  71.  71                         if (!string.IsNullOrEmpty(context.HttpContext.Request.QueryString.Value) && !string.IsNullOrWhiteSpace(context.HttpContext.Request.QueryString.Value))
  72.  72                         {
  73.  73                             parameterResult = context.HttpContext.Request.QueryString.Value;
  74.  74                         }
  75.  75 
  76.  76                         if (context.ActionArguments.ContainsKey("id"))
  77.  77                         {
  78.  78                             string? id = context.ActionDescriptor.RouteValues["id"];
  79.  79                             if (!string.IsNullOrEmpty(id) && !string.IsNullOrWhiteSpace(id))
  80.  80                             {
  81.  81                                 if (string.IsNullOrEmpty(parameterResult) || string.IsNullOrWhiteSpace(parameterResult))
  82.  82                                 {
  83.  83                                     parameterResult = $"id={id}";
  84.  84                                 }
  85.  85                                 else
  86.  86                                 {
  87.  87                                     parameterResult += $"&id={id}";
  88.  88                                 }
  89.  89                             }
  90.  90                         }
  91.  91                     }
  92.  92                     else
  93.  93                     {
  94.  94                         //获取 Post 方法传递的参数，读取 request.body 里的的参数, 必须在在 Program.cs 里也启用倒带功能
  95.  95                         context.HttpContext.Request.EnableBuffering();
  96.  96                         context.HttpContext.Request.Body.Position = 0;
  97.  97                         using (var memoryStream = new MemoryStream())
  98.  98                         {
  99.  99                             context.HttpContext.Request.Body.CopyTo(memoryStream);
  100. 100                             var streamBytes = memoryStream.ToArray();
  101. 101                             parameterResult = Encoding.UTF8.GetString(streamBytes);
  102. 102                         }
  103. 103                         //using (var reader = new StreamReader(context.HttpContext.Request.Body, Encoding.UTF8))
  104. 104                         //{
  105. 105                         // 　　var bodyRead = reader.ReadToEndAsync();
  106. 106                         // 　　bodyStr = bodyRead.Result;  //把body赋值给bodyStr
  107. 107                         // 　　needKey = JsonConvert.DeserializeAnonymousType
  108. 108                         //　　(bodyRead.Result, new Dictionary<string, object>())[dependencySource].ToString();
  109. 109                         //}
  110. 110                         if (controllerType != typeof(ValidationController))
  111. 111                         {
  112. 112                             parameterResult = ProcessFormParameters(parameterResult);
  113. 113                         }
  114. 114                         else
  115. 115                         {
  116. 116                             parameterResult = ProcessLoginUserNameParameters(parameterResult, out loginName);
  117. 117                         }
  118. 118                     }
  119. 119 
  120. 120                     parameterResult = !string.IsNullOrEmpty(parameterResult) ? parameterResult : "没有传递任何参数";
  121. 121                     loginName = !string.IsNullOrEmpty(loginName) ? loginName : "anonymous";
  122. 122                     Guid userid = Guid.Empty;
  123. 123                     if (string.IsNullOrEmpty(context.HttpContext.User.FindFirstValue(ClaimTypes.Sid)) || string.IsNullOrWhiteSpace(context.HttpContext.User.FindFirstValue(ClaimTypes.Sid)))
  124. 124                     {
  125. 125                         userid = Guid.Parse("a05897f9-0c86-4f5a-a581-e5da936d0e4c");
  126. 126                     }
  127. 127                     else
  128. 128                     {
  129. 129                         userid = Guid.Parse(context.HttpContext.User.FindFirstValue(ClaimTypes.Sid));
  130. 130                     }
  131. 131 
  132. 132                     OperationLog log = new OperationLog()
  133. 133                     {
  134. 134                         Id = Guid.NewGuid(),
  135. 135                         Name = $"{loginName} 执行 {controllerName}.{currentMethodName} 操作。",
  136. 136                         LoginName = loginName,
  137. 137                         Parameters = parameterResult,
  138. 138                         ActionName = $"{controllerType.FullName}.{currentMethodName}",
  139. 139                         ActionType = methodType,
  140. 140                         Message = $"【{loginName}】用户在【{currentDateTime.ToString("yyyy-MM-dd HH:mm:ss")}】执行了控制器【{controllerType.FullName}】的【{currentMethodName}】方法，执行方法的类型：{methodType}，执行方法所需的参数：【{parameterResult}】，操作顺利完成。",
  141. 141                         Remarks = "全局日志记录器记录的日志。",
  142. 142                         CreateUserId = userid,
  143. 143                         CreateDate = currentDateTime
  144. 144                     };
  145. 145 
  146. 146                     try
  147. 147                     {
  148. 148                         MethodInfo? methodInfo;
  149. 149                         //如果 Controller 类型配置了 RequiredLogAttribute 特性，说明这个 Controller 里面的所有方法都需要记录日志。
  150. 150                         //如果 Controler 配置了 RequiredLogAttribute 特性，但是方法配置 NoLogAttribute 特性，则不记录日志，否则记录日志。
  151. 151                         if (controllerType.IsDefined(typeof(RequiredLogAttribute), false))
  152. 152                         {
  153. 153                             methodInfo = controllerType.GetMethod(currentMethodName);
  154. 154                             if (methodInfo != null && !methodInfo.IsDefined(typeof(NoLogAttribute), false))
  155. 155                             {
  156. 156                                 await _operationLogService.InsertAsync(log);
  157. 157                             }
  158. 158                         }
  159. 159                         else
  160. 160                         {
  161. 161                             //针对方法配置了 RequiredLogAttribute 特性执行记录日志的功能
  162. 162                             methodInfo = controllerType.GetMethod(currentMethodName);
  163. 163                             if (methodInfo != null && methodInfo.IsDefined(typeof(RequiredLogAttribute), false))
  164. 164                             {
  165. 165                                 await _operationLogService.InsertAsync(log);
  166. 166                             }
  167. 167                         }
  168. 168                     }
  169. 169                     catch (Exception ex)
  170. 170                     {
  171. 171                         log.Name = $"异常操作日志：{loginName}在{currentDateTime.ToString("yyyy-MM-dd HH:mm:ss")}执行了{currentMethodName}操作。";
  172. 172                         log.Message = $"【{loginName}】用户在【{currentDateTime.ToString("yyyy-MM-dd HH:mm:ss")}】执行了控制器【{controllerType.FullName}】的【{currentMethodName}】方法，执行方法的类型：{methodType}，执行方法所需的参数：【{parameterResult}】，操作没有完成，系统发生了异常。<br/>异常详情：{ex.Message}，<br/>异常堆栈：{ex.StackTrace}。";
  173. 173 
  174. 174                         await _operationLogService.InsertAsync(log);
  175. 175                     }
  176. 176 
  177. 177                     #endregion
  178. 178                 }
  179. 179             }
  180. 180         }
  181. 181 
  182. 182         /// <summary>
  183. 183         /// 在标注方法执行之后执行该方法。
  184. 184         /// </summary>
  185. 185         /// <param name="context">方法执行后的上下文。</param>
  186. 186         public void OnActionExecuted(ActionExecutedContext context) { }
  187. 187 
  188. 188         #endregion
  189. 189 
  190. 190         #region 操作日志的异步方法
  191. 191 
  192. 192         /// <summary>
  193. 193         /// 全局日志记录器异步实现的操作日志的记录。
  194. 194         /// </summary>
  195. 195         /// <param name="context">方法执行前的上下文。</param>
  196. 196         /// <param name="next">方法执行的下一个环节代理。</param>
  197. 197         /// <returns></returns>
  198. 198         public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
  199. 199         {
  200. 200             if (context.Controller.GetType() != typeof(ErrorHandlerController))
  201. 201             {
  202. 202                 if (context.ActionDescriptor.EndpointMetadata.Any(c => c.GetType() == typeof(RequiredLogAttribute)))
  203. 203                 {
  204. 204                     #region 核心处理
  205. 205 
  206. 206                     var controllerType = context.Controller.GetType();
  207. 207                     var controllerName = controllerType.Name;
  208. 208                     var currentMethodName = context.ActionDescriptor.RouteValues["action"]!;
  209. 209 
  210. 210                     string? loginName = string.Empty;
  211. 211                     var claimKeysProvider = _serviceProvider.GetService<ClaimKeysConstProvider>();
  212. 212                     if (claimKeysProvider != null)
  213. 213                     {
  214. 214                         loginName = context.HttpContext.User.FindFirstValue(claimKeysProvider.ClaimStoreUserNameKey);
  215. 215                     }
  216. 216 
  217. 217                     var currentDateTime = DateTime.Now;
  218. 218                     var methodType = context.HttpContext.Request.Method;
  219. 219                     string parameterResult = string.Empty;
  220. 220                     //获取 Get 方法传递的参数，包括查询参数（queryString的值）和Id（{controller=home}/{action=index}/{id?}）值，路由配置中的Id。
  221. 221                     if (string.Compare(methodType, "get", true) == 0)
  222. 222                     {
  223. 223                         if (!string.IsNullOrEmpty(context.HttpContext.Request.QueryString.Value) && !string.IsNullOrWhiteSpace(context.HttpContext.Request.QueryString.Value))
  224. 224                         {
  225. 225                             parameterResult = context.HttpContext.Request.QueryString.Value;
  226. 226                         }
  227. 227 
  228. 228                         if (context.ActionArguments.ContainsKey("id"))
  229. 229                         {
  230. 230                             string? id = context.ActionArguments["id"]!.ToString();
  231. 231                             if (!string.IsNullOrEmpty(id) && !string.IsNullOrWhiteSpace(id))
  232. 232                             {
  233. 233                                 if (string.IsNullOrEmpty(parameterResult) || string.IsNullOrWhiteSpace(parameterResult))
  234. 234                                 {
  235. 235                                     parameterResult = $"id={id}";
  236. 236                                 }
  237. 237                                 else
  238. 238                                 {
  239. 239                                     parameterResult += $"&id={id}";
  240. 240                                 }
  241. 241                             }
  242. 242                         }
  243. 243                     }
  244. 244                     else
  245. 245                     {
  246. 246                         //获取 Post 方法传递的参数，读取 request.body 里的的参数, 必须在在 Program.cs 里也启用倒带功能
  247. 247                         context.HttpContext.Request.EnableBuffering();
  248. 248                         context.HttpContext.Request.Body.Position = 0;
  249. 249                         using (var memoryStream = new MemoryStream())
  250. 250                         {
  251. 251                             context.HttpContext.Request.Body.CopyTo(memoryStream);
  252. 252                             var streamBytes = memoryStream.ToArray();
  253. 253                             parameterResult = Encoding.UTF8.GetString(streamBytes);
  254. 254                         }
  255. 255                         //using (var reader = new StreamReader(context.HttpContext.Request.Body, Encoding.UTF8))
  256. 256                         //{
  257. 257                         // 　　var bodyRead = reader.ReadToEndAsync();
  258. 258                         // 　　bodyStr = bodyRead.Result;  //把body赋值给bodyStr
  259. 259                         // 　　needKey = JsonConvert.DeserializeAnonymousType
  260. 260                         //　　(bodyRead.Result, new Dictionary<string, object>())[dependencySource].ToString();
  261. 261                         //}
  262. 262                         if (controllerType != typeof(ValidationController))
  263. 263                         {
  264. 264                             parameterResult = ProcessFormParameters(parameterResult);
  265. 265                         }
  266. 266                         else
  267. 267                         {
  268. 268                             parameterResult = ProcessLoginUserNameParameters(parameterResult, out loginName);
  269. 269                         }
  270. 270                     }
  271. 271 
  272. 272                     parameterResult = !string.IsNullOrEmpty(parameterResult) ? parameterResult : "没有传递任何参数";
  273. 273                     loginName = !string.IsNullOrEmpty(loginName) ? loginName : "anonymous";
  274. 274                     Guid userid = Guid.Empty;
  275. 275                     if (string.IsNullOrEmpty(context.HttpContext.User.FindFirstValue(ClaimTypes.Sid)) || string.IsNullOrWhiteSpace(context.HttpContext.User.FindFirstValue(ClaimTypes.Sid)))
  276. 276                     {
  277. 277                         userid = Guid.Parse("a05897f9-0c86-4f5a-a581-e5da936d0e4c");
  278. 278                     }
  279. 279                     else
  280. 280                     {
  281. 281                         userid = Guid.Parse(context.HttpContext.User.FindFirstValue(ClaimTypes.Sid));
  282. 282                     }
  283. 283 
  284. 284                     OperationLog log = new OperationLog()
  285. 285                     {
  286. 286                         Id = Guid.NewGuid(),
  287. 287                         Name = $"{loginName} 执行 {controllerName}.{currentMethodName} 操作。",
  288. 288                         LoginName = loginName,
  289. 289                         Parameters = parameterResult,
  290. 290                         ActionName = $"{controllerType.FullName}.{currentMethodName}",
  291. 291                         ActionType = methodType,
  292. 292                         Message = $"【{loginName}】用户在【{currentDateTime.ToString("yyyy-MM-dd HH:mm:ss")}】执行了控制器【{controllerType.FullName}】的【{currentMethodName}】方法，执行方法的类型：{methodType}，执行方法所需的参数：【{parameterResult}】，操作顺利完成。",
  293. 293                         Remarks = "全局日志记录器记录的日志。",
  294. 294                         CreateUserId = userid,
  295. 295                         CreateDate = currentDateTime
  296. 296                     };
  297. 297 
  298. 298                     try
  299. 299                     {
  300. 300                         MethodInfo? methodInfo;
  301. 301                         //如果 Controller 类型配置了 RequiredLogAttribute 特性，说明这个 Controller 里面的所有方法都需要记录日志。
  302. 302                         //如果 Controler 配置了 RequiredLogAttribute 特性，但是方法配置 NoLogAttribute 特性，则不记录日志，否则记录日志。
  303. 303                         if (controllerType.IsDefined(typeof(RequiredLogAttribute), false))
  304. 304                         {
  305. 305                             methodInfo = controllerType.GetMethod(currentMethodName);
  306. 306                             if (methodInfo != null && !methodInfo.IsDefined(typeof(NoLogAttribute), false))
  307. 307                             {
  308. 308                                 await _operationLogService.InsertAsync(log);
  309. 309                             }
  310. 310                         }
  311. 311                         else
  312. 312                         {
  313. 313                             //针对方法配置了 RequiredLogAttribute 特性执行记录日志的功能
  314. 314                             methodInfo = controllerType.GetMethod(currentMethodName);
  315. 315                             if (methodInfo != null && methodInfo.IsDefined(typeof(RequiredLogAttribute), false))
  316. 316                             {
  317. 317                                 await _operationLogService.InsertAsync(log);
  318. 318                             }
  319. 319                         }
  320. 320                     }
  321. 321                     catch (Exception ex)
  322. 322                     {
  323. 323                         log.Name = $"异常操作日志：{loginName}在{currentDateTime.ToString("yyyy-MM-dd HH:mm:ss")}执行了{currentMethodName}操作。";
  324. 324                         log.Message = $"【{loginName}】用户在【{currentDateTime.ToString("yyyy-MM-dd HH:mm:ss")}】执行了控制器【{controllerType.FullName}】的【{currentMethodName}】方法，执行方法的类型：{methodType}，执行方法所需的参数：【{parameterResult}】，操作没有完成，系统发生了异常。<br/>异常详情：{ex.Message}，<br/>异常堆栈：{ex.StackTrace}。";
  325. 325 
  326. 326                         await _operationLogService.InsertAsync(log);
  327. 327                     }
  328. 328 
  329. 329                     #endregion
  330. 330                 }
  331. 331             }
  332. 332 
  333. 333             await next.Invoke();
  334. 334         }
  335. 335 
  336. 336         /// <summary>
  337. 337         /// 处理用户登录页面所传递的参数，如果包含用户的登录密码，替换成星号。
  338. 338         /// </summary>
  339. 339         /// <param name="parameters">要处理的参数字符串。</param>
  340. 340         /// <param name="loginName">返回用户的登录系统的用户名称。</param>
  341. 341         /// <returns></returns>
  342. 342         private string ProcessLoginUserNameParameters(string parameters, out string loginName)
  343. 343         {
  344. 344             loginName = string.Empty;
  345. 345             if (parameters.IndexOf("&__RequestVerificationToken") != -1)
  346. 346             {
  347. 347                 parameters = parameters.Substring(0, parameters.LastIndexOf("&__RequestVerificationToken"));
  348. 348                 if (parameters.IndexOf("userName=") != -1)
  349. 349                 {
  350. 350                     loginName = parameters.Substring("userName=".Length, parameters.IndexOf("&password") - "&password".Length);
  351. 351                     parameters = $"{parameters.Substring(0, parameters.LastIndexOf("=") + 1)}*********";
  352. 352                 }
  353. 353             }
  354. 354             else
  355. 355             {
  356. 356                 if (parameters.IndexOf("userName=") != -1)
  357. 357                 {
  358. 358                     loginName = parameters.Substring("userName=".Length, parameters.IndexOf("&password") - "&password".Length);
  359. 359                     parameters = $"{parameters.Substring(0, parameters.LastIndexOf("=") + 1)}*********";
  360. 360                 }
  361. 361             }
  362. 362             return parameters;
  363. 363         }
  364. 364 
  365. 365         /// <summary>
  366. 366         /// 返回经过处理的 Form 表单参数。
  367. 367         /// </summary>
  368. 368         /// <param name="originalFormParameters">未经处理的、原始的 Form 表单参数。</param>
  369. 369         /// <returns></returns>
  370. 370         private string ProcessFormParameters(string originalFormParameters)
  371. 371         {
  372. 372             string result = "没有 Form 表单参数。";
  373. 373             if (string.IsNullOrEmpty(originalFormParameters) || string.IsNullOrWhiteSpace(originalFormParameters))
  374. 374             {
  375. 375                 return result;
  376. 376             }
  377. 377 
  378. 378             if (originalFormParameters.IndexOf("=") != -1 && (originalFormParameters.IndexOf("=") != originalFormParameters.LastIndexOf("=")))
  379. 379             {
  380. 380                 var formParameters = originalFormParameters.Split(new string[] { "-----------------------------", "Content-Disposition: form-data;" }, StringSplitOptions.RemoveEmptyEntries);
  381. 381                 var filterParameter = new List<string>();
  382. 382 
  383. 383                 //获取参数数据，包含=等号的就是form表单的值
  384. 384                 foreach (var parameter in formParameters)
  385. 385                 {
  386. 386                     if (parameter.IndexOf("=") != -1 && parameter.IndexOf("__RequestVerificationToken", StringComparison.CurrentCultureIgnoreCase) == -1)
  387. 387                     {
  388. 388                         filterParameter.Add(parameter);
  389. 389                     }
  390. 390                 }
  391. 391                 //整理表单数据格式为：name='xxxx' value='yyyyyy'\r\nname='xxxx2' value='yyyyyy2'....
  392. 392                 if (filterParameter.Count > 0)
  393. 393                 {
  394. 394                     for (int i = 0; i < filterParameter.Count; i++)
  395. 395                     {
  396. 396                         filterParameter[i] = ProcessCore(filterParameter[i]);
  397. 397                     }
  398. 398                 }
  399. 399 
  400. 400                 //凭借结果值，并返回。
  401. 401                 if (filterParameter.Count > 0)
  402. 402                 {
  403. 403                     result = string.Join("\r\n", filterParameter);
  404. 404                 }
  405. 405             }
  406. 406 
  407. 407             return result;
  408. 408         }
  409. 409 
  410. 410         /// <summary>
  411. 411         /// 递归的处理参数的格式，将格式转换为 name='xxxx' value='yyyyyy'。
  412. 412         /// </summary>
  413. 413         /// <param name="parameter">要处理的参数。</param>
  414. 414         /// <returns>返回处理好的参数。</returns>
  415. 415         private string ProcessCore(string parameter)
  416. 416         {
  417. 417             //过滤Form表单中的图片，只获取字段名和值，具体上传文件的数据不保留。
  418. 418             if (parameter.IndexOf("Content-Type: image/", StringComparison.CurrentCultureIgnoreCase) != -1)
  419. 419             {
  420. 420                 parameter = parameter.Substring(0, parameter.IndexOf("Content-Type: image/"));
  421. 421             }
  422. 422             else if (parameter.IndexOf("\"") != -1)//替换数据中的斜杠和双引号为单引号
  423. 423             {
  424. 424                 parameter = parameter.Replace("\"", "'");
  425. 425             }
  426. 426             else if (parameter.IndexOf("\r\n\r\n") != -1)
  427. 427             //替换数据中的两个换行符为value='，格式：“name=\"Details\"\r\n\r\n<p>asdfsadfas</p><p>asdfsadf</p><p>fasdfsadfsadf</p>\r\n”== “name=\"Details\" value='<p>asdfsadfas</p><p>asdfsadf</p><p>fasdfsadfsadf</p>'”
  428. 428             {
  429. 429                 parameter = parameter.Replace("\r\n\r\n", " value='");
  430. 430             }
  431. 431             else if (parameter.EndsWith("\r\n"))
  432. 432             //替换数据尾部的换行符为单引号，格式：“name=\"Details\"\r\n\r\n<p>asdfsadfas</p><p>asdfsadf</p><p>fasdfsadfsadf</p>\r\n”== “name=\"Details\"\r\n\r\n<p>asdfsadfas</p><p>asdfsadf</p><p>fasdfsadfsadf</p>'”
  433. 433             {
  434. 434                 parameter = parameter.Replace("\r\n", "'");
  435. 435             }
  436. 436             else if (parameter.IndexOf(";") != -1)
  437. 437             {
  438. 438                 parameter = parameter.Replace(";", " ");
  439. 439             }
  440. 440             else if (parameter.IndexOf("''") != -1)
  441. 441             {
  442. 442                 parameter = parameter.Replace("''", "'");
  443. 443             }
  444. 444             else
  445. 445             {
  446. 446                 return parameter;
  447. 447             }
  448. 448             return ProcessCore(parameter);
  449. 449         }
  450. 450 
  451. 451         #endregion
  452. 452     }
  453. 453 }

 


三、总结
　　　　好了，写完了，今天又解决了一个问题，知识和技能就是在出现问题和解决问题的过程中积累的，不忘初心，继续努力，老天不会亏待努力的人。

原文链接：https://www.cnblogs.com/PatrickLiu/p/17445451.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

ASP.net热门文章

  • 【Dotnet 工具箱】WPF UI - 现代化设计的开源 WPF 框架
  • net core 使用 SqlSugar
  • .NETCore下CI/CD之自动化测试
  • .net core部署到linux可能碰到的问题
  • Abp vNext 自定义 Ef Core 仓储引发异常
  • .NetCore 消息队列的使用
  • .NetCore WebApi——基于JWT的简单身份认证与授权（Swagger）
  • Abp.NHibernate连接PostgreSQl数据库
  • ModelValidator基于元数据的验证
  • .NET MAUI 安卓应用开发初体验

    • ASP.net推荐文章

  • Gradio.NET 支持 .NET 8 简化 Web 应用开发
  • .NET 轻量化定时任务调度 FreeScheduler
  • WPF 模仿前端大佬写一个Hover效果
  • WPF 模拟UWP原生窗口样式——亚克力|云母材质、自定义标题栏样式、原生DWM动画 （附我封装好的类）
  • .NET 音频采集
  • .NET8 Blazor 从入门到精通：（三）类库和表单
  • wpf 如何7步写一个badge控件
  • .NET 高效Nuget管理工具（开源）
  • .NET 8 跨平台高性能边缘采集网关
  • .NET 窗口/屏幕录制

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号