在 Net Core 开发中如何解决 Cannot access a disposed object 这个问题

一、简介
　　　　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

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

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

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

using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Mvc.Razor;
using Microsoft.AspNetCore.Server.Kestrel.Core;
using OpticalTrap.Framework.DataAccessors;
using OpticalTrap.Web.Facade.Extensions.Filters;
using OpticalTrap.Web.Facade.Utilities;
using OpticalTrap.Web.ServiceManager;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews(option =>
{
    option.Filters.Add(typeof(GlobalAuthorizationFilterAttribute));
    option.Filters.Add(typeof(GlobalOperationLogFilterAttribute));
}).AddXmlSerializerFormatters();

#region 第一步：配置可以同步请求读取流数据

builder.Services.Configure<KestrelServerOptions>(k => k.AllowSynchronousIO = true)
    .Configure<IISServerOptions>(k => k.AllowSynchronousIO = true);

#endregion

#region 配置日志

builder.Logging.AddLog4Net("ConfigFiles/log4net.config");

#endregion

#region 配置 Session

builder.Services.AddSession();

#endregion

#region 配置数据库

builder.Services.AddTransientSqlSugar(builder.Configuration["ConnectionStrings:DefaultConnectionString"]);

#endregion

#region 配置区域

builder.Services.Configure<RazorViewEngineOptions>(option =>
{
    option.AreaViewLocationFormats.Clear();
    option.AreaViewLocationFormats.Add("/Areas/{2}/Views/{1}/{0}.cshtml");
    option.AreaViewLocationFormats.Add("/Areas/{2}/Views/Shared/{0}.cshtml");
    option.AreaViewLocationFormats.Add("/Views/Shared/{0}.cshtml");
});

#endregion

#region 配置服务实例

builder.Services.AddBusinessServices();
builder.Services.AddUtilityServices();
builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
builder.Services.AddSingleton<SessionCacheObjectProvider>();
builder.Services.AddTransient<AuthorizedDataGridGeneratorWrapper>();
builder.Services.AddSingleton<PageNumberGenerator>();

#endregion

#region 认证设置

builder.Services.AddAuthentication(option =>
{
    option.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    option.DefaultChallengeScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    option.DefaultSignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    option.DefaultForbidScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    option.DefaultSignOutScheme = CookieAuthenticationDefaults.AuthenticationScheme;
}).AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, options =>
{
    options.LoginPath = "/Validation/Index";
    options.LogoutPath = "/Validation/Logout";
    options.AccessDeniedPath = "/Validation/Index";
    options.Cookie.HttpOnly = true;
    options.ClaimsIssuer = "Cookie";
});

#endregion

var app = builder.Build();

//第二步：启用倒带, 在发生异常时, 可以通过过滤器获取post参数
app.Use((context, next) =>
{
    context.Request.EnableBuffering();
    return next(context);
});

if (app.Environment.IsProduction())
{
    app.UseStatusCodePagesWithReExecute("/ErrorHandler/HttpStatusCode", "?statusCode={0}");
    app.UseExceptionHandler("/ErrorHandler/ExceptionHandler");
}
else
{
    app.UseDeveloperExceptionPage();
}

app.UseStaticFiles();

app.UseSession();
app.UseRouting();

app.UseAuthentication();
app.UseAuthorization();

app.MapControllerRoute("defaultAreaRoute", "{area:exists}/{controller=Home}/{action=Index}/{id?}");

app.MapControllerRoute("defaultRoute", "{controller=Home}/{action=Index}/{id?}");

app.Run();

 
        我写了一个过滤器（实现日志功能），实现的是IActionFilter 过滤器，在过滤器中，获取Post请求Body的Context使用下面方式获取强调（强调，关注红色字体，其他无关，这是我写的日志功能，贴全部代码，便于以后查阅，不喜勿喷）

using Microsoft.AspNetCore.Mvc.Filters;
using OpticalTrap.Framework.Loggings;
using OpticalTrap.Web.ConstProvider;
using OpticalTrap.Web.Contracts;
using OpticalTrap.Web.Facade.Controllers;
using OpticalTrap.Web.Models;
using System.Reflection;
using System.Security.Claims;
using System.Text;

namespace OpticalTrap.Web.Facade.Extensions.Filters
{
    /// <summary>
    /// 该类型定义了全局处理操作日志的过滤器，该类型是密封类型。
    /// </summary>
    public sealed class GlobalOperationLogFilterAttribute : Attribute, IActionFilter, IAsyncActionFilter
    {
        #region 实例字段

        private readonly IOperationLogService _operationLogService;
        private readonly IServiceProvider _serviceProvider;

        #endregion

        #region 构造函数

        /// <summary>
        /// 初始化该类型的新实例。
        /// </summary>
        /// <param name="operationLogService">需要注入的操作日志服务实例。</param>
        /// <param name="serviceProvider">需要注入的服务提供器。</param>
        public GlobalOperationLogFilterAttribute(IOperationLogService operationLogService, IServiceProvider serviceProvider)
        {
            _operationLogService = operationLogService;
            _serviceProvider = serviceProvider;
        }

        #endregion

        #region 操作日志的同步方法

        /// <summary>
        /// 在标注方法执行之前执行该方法。
        /// </summary>
        /// <param name="context">方法执行前的上下文。</param>
        public async void OnActionExecuting(ActionExecutingContext context)
        {
            if (context.Controller.GetType() != typeof(ErrorHandlerController))
            {
                if (context.ActionDescriptor.EndpointMetadata.Any(c => c.GetType() == typeof(RequiredLogAttribute)))
                {
                    #region 核心处理

                    var controllerType = context.Controller.GetType();
                    var controllerName = controllerType.Name;
                    var currentMethodName = context.ActionDescriptor.RouteValues["action"]!;

                    string? loginName = string.Empty;
                    var claimKeysProvider = _serviceProvider.GetService<ClaimKeysConstProvider>();
                    if (claimKeysProvider != null)
                    {
                        loginName = context.HttpContext.User.FindFirstValue(claimKeysProvider.ClaimStoreUserNameKey);
                    }

                    var currentDateTime = DateTime.Now;
                    var methodType = context.HttpContext.Request.Method;
                    string parameterResult = string.Empty;
                    //获取 Get 方法传递的参数，包括查询参数（queryString的值）和Id（{controller=home}/{action=index}/{id?}）值，路由配置中的Id。
                    if (string.Compare(methodType, "get", true) == 0)
                    {
                        if (!string.IsNullOrEmpty(context.HttpContext.Request.QueryString.Value) && !string.IsNullOrWhiteSpace(context.HttpContext.Request.QueryString.Value))
                        {
                            parameterResult = context.HttpContext.Request.QueryString.Value;
                        }

                        if (context.ActionArguments.ContainsKey("id"))
                        {
                            string? id = context.ActionDescriptor.RouteValues["id"];
                            if (!string.IsNullOrEmpty(id) && !string.IsNullOrWhiteSpace(id))
                            {
                                if (string.IsNullOrEmpty(parameterResult) || string.IsNullOrWhiteSpace(parameterResult))
                                {
                                    parameterResult = $"id={id}";
                                }
                                else
                                {
                                    parameterResult += $"&id={id}";
                                }
                            }
                        }
                    }
                    else
                    {
                        //获取 Post 方法传递的参数，读取 request.body 里的的参数, 必须在在 Program.cs 里也启用倒带功能
                        context.HttpContext.Request.EnableBuffering();
                        context.HttpContext.Request.Body.Position = 0;
                        using (var memoryStream = new MemoryStream())
                        {
                            context.HttpContext.Request.Body.CopyTo(memoryStream);
                            var streamBytes = memoryStream.ToArray();
                            parameterResult = Encoding.UTF8.GetString(streamBytes);
                        }
                        //using (var reader = new StreamReader(context.HttpContext.Request.Body, Encoding.UTF8))
                        //{
                        // 　　var bodyRead = reader.ReadToEndAsync();
                        // 　　bodyStr = bodyRead.Result;  //把body赋值给bodyStr
                        // 　　needKey = JsonConvert.DeserializeAnonymousType
                        //　　(bodyRead.Result, new Dictionary<string, object>())[dependencySource].ToString();
                        //}
                        if (controllerType != typeof(ValidationController))
                        {
                            parameterResult = ProcessFormParameters(parameterResult);
                        }
                        else
                        {
                            parameterResult = ProcessLoginUserNameParameters(parameterResult, out loginName);
                        }
                    }

                    parameterResult = !string.IsNullOrEmpty(parameterResult) ? parameterResult : "没有传递任何参数";
                    loginName = !string.IsNullOrEmpty(loginName) ? loginName : "anonymous";
                    Guid userid = Guid.Empty;
                    if (string.IsNullOrEmpty(context.HttpContext.User.FindFirstValue(ClaimTypes.Sid)) || string.IsNullOrWhiteSpace(context.HttpContext.User.FindFirstValue(ClaimTypes.Sid)))
                    {
                        userid = Guid.Parse("a05897f9-0c86-4f5a-a581-e5da936d0e4c");
                    }
                    else
                    {
                        userid = Guid.Parse(context.HttpContext.User.FindFirstValue(ClaimTypes.Sid));
                    }

                    OperationLog log = new OperationLog()
                    {
                        Id = Guid.NewGuid(),
                        Name = $"{loginName} 执行 {controllerName}.{currentMethodName} 操作。",
                        LoginName = loginName,
                        Parameters = parameterResult,
                        ActionName = $"{controllerType.FullName}.{currentMethodName}",
                        ActionType = methodType,
                        Message = $"【{loginName}】用户在【{currentDateTime.ToString("yyyy-MM-dd HH:mm:ss")}】执行了控制器【{controllerType.FullName}】的【{currentMethodName}】方法，执行方法的类型：{methodType}，执行方法所需的参数：【{parameterResult}】，操作顺利完成。",
                        Remarks = "全局日志记录器记录的日志。",
                        CreateUserId = userid,
                        CreateDate = currentDateTime
                    };

                    try
                    {
                        MethodInfo? methodInfo;
                        //如果 Controller 类型配置了 RequiredLogAttribute 特性，说明这个 Controller 里面的所有方法都需要记录日志。
                        //如果 Controler 配置了 RequiredLogAttribute 特性，但是方法配置 NoLogAttribute 特性，则不记录日志，否则记录日志。
                        if (controllerType.IsDefined(typeof(RequiredLogAttribute), false))
                        {
                            methodInfo = controllerType.GetMethod(currentMethodName);
                            if (methodInfo != null && !methodInfo.IsDefined(typeof(NoLogAttribute), false))
                            {
                                await _operationLogService.InsertAsync(log);
                            }
                        }
                        else
                        {
                            //针对方法配置了 RequiredLogAttribute 特性执行记录日志的功能
                            methodInfo = controllerType.GetMethod(currentMethodName);
                            if (methodInfo != null && methodInfo.IsDefined(typeof(RequiredLogAttribute), false))
                            {
                                await _operationLogService.InsertAsync(log);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        log.Name = $"异常操作日志：{loginName}在{currentDateTime.ToString("yyyy-MM-dd HH:mm:ss")}执行了{currentMethodName}操作。";
                        log.Message = $"【{loginName}】用户在【{currentDateTime.ToString("yyyy-MM-dd HH:mm:ss")}】执行了控制器【{controllerType.FullName}】的【{currentMethodName}】方法，执行方法的类型：{methodType}，执行方法所需的参数：【{parameterResult}】，操作没有完成，系统发生了异常。<br/>异常详情：{ex.Message}，<br/>异常堆栈：{ex.StackTrace}。";

                        await _operationLogService.InsertAsync(log);
                    }

                    #endregion
                }
            }
        }

        /// <summary>
        /// 在标注方法执行之后执行该方法。
        /// </summary>
        /// <param name="context">方法执行后的上下文。</param>
        public void OnActionExecuted(ActionExecutedContext context) { }

        #endregion

        #region 操作日志的异步方法

        /// <summary>
        /// 全局日志记录器异步实现的操作日志的记录。
        /// </summary>
        /// <param name="context">方法执行前的上下文。</param>
        /// <param name="next">方法执行的下一个环节代理。</param>
        /// <returns></returns>
        public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
        {
            if (context.Controller.GetType() != typeof(ErrorHandlerController))
            {
                if (context.ActionDescriptor.EndpointMetadata.Any(c => c.GetType() == typeof(RequiredLogAttribute)))
                {
                    #region 核心处理

                    var controllerType = context.Controller.GetType();
                    var controllerName = controllerType.Name;
                    var currentMethodName = context.ActionDescriptor.RouteValues["action"]!;

                    string? loginName = string.Empty;
                    var claimKeysProvider = _serviceProvider.GetService<ClaimKeysConstProvider>();
                    if (claimKeysProvider != null)
                    {
                        loginName = context.HttpContext.User.FindFirstValue(claimKeysProvider.ClaimStoreUserNameKey);
                    }

                    var currentDateTime = DateTime.Now;
                    var methodType = context.HttpContext.Request.Method;
                    string parameterResult = string.Empty;
                    //获取 Get 方法传递的参数，包括查询参数（queryString的值）和Id（{controller=home}/{action=index}/{id?}）值，路由配置中的Id。
                    if (string.Compare(methodType, "get", true) == 0)
                    {
                        if (!string.IsNullOrEmpty(context.HttpContext.Request.QueryString.Value) && !string.IsNullOrWhiteSpace(context.HttpContext.Request.QueryString.Value))
                        {
                            parameterResult = context.HttpContext.Request.QueryString.Value;
                        }

                        if (context.ActionArguments.ContainsKey("id"))
                        {
                            string? id = context.ActionArguments["id"]!.ToString();
                            if (!string.IsNullOrEmpty(id) && !string.IsNullOrWhiteSpace(id))
                            {
                                if (string.IsNullOrEmpty(parameterResult) || string.IsNullOrWhiteSpace(parameterResult))
                                {
                                    parameterResult = $"id={id}";
                                }
                                else
                                {
                                    parameterResult += $"&id={id}";
                                }
                            }
                        }
                    }
                    else
                    {
                        //获取 Post 方法传递的参数，读取 request.body 里的的参数, 必须在在 Program.cs 里也启用倒带功能
                        context.HttpContext.Request.EnableBuffering();
                        context.HttpContext.Request.Body.Position = 0;
                        using (var memoryStream = new MemoryStream())
                        {
                            context.HttpContext.Request.Body.CopyTo(memoryStream);
                            var streamBytes = memoryStream.ToArray();
                            parameterResult = Encoding.UTF8.GetString(streamBytes);
                        }
                        //using (var reader = new StreamReader(context.HttpContext.Request.Body, Encoding.UTF8))
                        //{
                        // 　　var bodyRead = reader.ReadToEndAsync();
                        // 　　bodyStr = bodyRead.Result;  //把body赋值给bodyStr
                        // 　　needKey = JsonConvert.DeserializeAnonymousType
                        //　　(bodyRead.Result, new Dictionary<string, object>())[dependencySource].ToString();
                        //}
                        if (controllerType != typeof(ValidationController))
                        {
                            parameterResult = ProcessFormParameters(parameterResult);
                        }
                        else
                        {
                            parameterResult = ProcessLoginUserNameParameters(parameterResult, out loginName);
                        }
                    }

                    parameterResult = !string.IsNullOrEmpty(parameterResult) ? parameterResult : "没有传递任何参数";
                    loginName = !string.IsNullOrEmpty(loginName) ? loginName : "anonymous";
                    Guid userid = Guid.Empty;
                    if (string.IsNullOrEmpty(context.HttpContext.User.FindFirstValue(ClaimTypes.Sid)) || string.IsNullOrWhiteSpace(context.HttpContext.User.FindFirstValue(ClaimTypes.Sid)))
                    {
                        userid = Guid.Parse("a05897f9-0c86-4f5a-a581-e5da936d0e4c");
                    }
                    else
                    {
                        userid = Guid.Parse(context.HttpContext.User.FindFirstValue(ClaimTypes.Sid));
                    }

                    OperationLog log = new OperationLog()
                    {
                        Id = Guid.NewGuid(),
                        Name = $"{loginName} 执行 {controllerName}.{currentMethodName} 操作。",
                        LoginName = loginName,
                        Parameters = parameterResult,
                        ActionName = $"{controllerType.FullName}.{currentMethodName}",
                        ActionType = methodType,
                        Message = $"【{loginName}】用户在【{currentDateTime.ToString("yyyy-MM-dd HH:mm:ss")}】执行了控制器【{controllerType.FullName}】的【{currentMethodName}】方法，执行方法的类型：{methodType}，执行方法所需的参数：【{parameterResult}】，操作顺利完成。",
                        Remarks = "全局日志记录器记录的日志。",
                        CreateUserId = userid,
                        CreateDate = currentDateTime
                    };

                    try
                    {
                        MethodInfo? methodInfo;
                        //如果 Controller 类型配置了 RequiredLogAttribute 特性，说明这个 Controller 里面的所有方法都需要记录日志。
                        //如果 Controler 配置了 RequiredLogAttribute 特性，但是方法配置 NoLogAttribute 特性，则不记录日志，否则记录日志。
                        if (controllerType.IsDefined(typeof(RequiredLogAttribute), false))
                        {
                            methodInfo = controllerType.GetMethod(currentMethodName);
                            if (methodInfo != null && !methodInfo.IsDefined(typeof(NoLogAttribute), false))
                            {
                                await _operationLogService.InsertAsync(log);
                            }
                        }
                        else
                        {
                            //针对方法配置了 RequiredLogAttribute 特性执行记录日志的功能
                            methodInfo = controllerType.GetMethod(currentMethodName);
                            if (methodInfo != null && methodInfo.IsDefined(typeof(RequiredLogAttribute), false))
                            {
                                await _operationLogService.InsertAsync(log);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        log.Name = $"异常操作日志：{loginName}在{currentDateTime.ToString("yyyy-MM-dd HH:mm:ss")}执行了{currentMethodName}操作。";
                        log.Message = $"【{loginName}】用户在【{currentDateTime.ToString("yyyy-MM-dd HH:mm:ss")}】执行了控制器【{controllerType.FullName}】的【{currentMethodName}】方法，执行方法的类型：{methodType}，执行方法所需的参数：【{parameterResult}】，操作没有完成，系统发生了异常。<br/>异常详情：{ex.Message}，<br/>异常堆栈：{ex.StackTrace}。";

                        await _operationLogService.InsertAsync(log);
                    }

                    #endregion
                }
            }

            await next.Invoke();
        }

        /// <summary>
        /// 处理用户登录页面所传递的参数，如果包含用户的登录密码，替换成星号。
        /// </summary>
        /// <param name="parameters">要处理的参数字符串。</param>
        /// <param name="loginName">返回用户的登录系统的用户名称。</param>
        /// <returns></returns>
        private string ProcessLoginUserNameParameters(string parameters, out string loginName)
        {
            loginName = string.Empty;
            if (parameters.IndexOf("&__RequestVerificationToken") != -1)
            {
                parameters = parameters.Substring(0, parameters.LastIndexOf("&__RequestVerificationToken"));
                if (parameters.IndexOf("userName=") != -1)
                {
                    loginName = parameters.Substring("userName=".Length, parameters.IndexOf("&password") - "&password".Length);
                    parameters = $"{parameters.Substring(0, parameters.LastIndexOf("=") + 1)}*********";
                }
            }
            else
            {
                if (parameters.IndexOf("userName=") != -1)
                {
                    loginName = parameters.Substring("userName=".Length, parameters.IndexOf("&password") - "&password".Length);
                    parameters = $"{parameters.Substring(0, parameters.LastIndexOf("=") + 1)}*********";
                }
            }
            return parameters;
        }

        /// <summary>
        /// 返回经过处理的 Form 表单参数。
        /// </summary>
        /// <param name="originalFormParameters">未经处理的、原始的 Form 表单参数。</param>
        /// <returns></returns>
        private string ProcessFormParameters(string originalFormParameters)
        {
            string result = "没有 Form 表单参数。";
            if (string.IsNullOrEmpty(originalFormParameters) || string.IsNullOrWhiteSpace(originalFormParameters))
            {
                return result;
            }

            if (originalFormParameters.IndexOf("=") != -1 && (originalFormParameters.IndexOf("=") != originalFormParameters.LastIndexOf("=")))
            {
                var formParameters = originalFormParameters.Split(new string[] { "-----------------------------", "Content-Disposition: form-data;" }, StringSplitOptions.RemoveEmptyEntries);
                var filterParameter = new List<string>();

                //获取参数数据，包含=等号的就是form表单的值
                foreach (var parameter in formParameters)
                {
                    if (parameter.IndexOf("=") != -1 && parameter.IndexOf("__RequestVerificationToken", StringComparison.CurrentCultureIgnoreCase) == -1)
                    {
                        filterParameter.Add(parameter);
                    }
                }
                //整理表单数据格式为：name='xxxx' value='yyyyyy'\r\nname='xxxx2' value='yyyyyy2'....
                if (filterParameter.Count > 0)
                {
                    for (int i = 0; i < filterParameter.Count; i++)
                    {
                        filterParameter[i] = ProcessCore(filterParameter[i]);
                    }
                }

                //凭借结果值，并返回。
                if (filterParameter.Count > 0)
                {
                    result = string.Join("\r\n", filterParameter);
                }
            }

            return result;
        }

        /// <summary>
        /// 递归的处理参数的格式，将格式转换为 name='xxxx' value='yyyyyy'。
        /// </summary>
        /// <param name="parameter">要处理的参数。</param>
        /// <returns>返回处理好的参数。</returns>
        private string ProcessCore(string parameter)
        {
            //过滤Form表单中的图片，只获取字段名和值，具体上传文件的数据不保留。
            if (parameter.IndexOf("Content-Type: image/", StringComparison.CurrentCultureIgnoreCase) != -1)
            {
                parameter = parameter.Substring(0, parameter.IndexOf("Content-Type: image/"));
            }
            else if (parameter.IndexOf("\"") != -1)//替换数据中的斜杠和双引号为单引号
            {
                parameter = parameter.Replace("\"", "'");
            }
            else if (parameter.IndexOf("\r\n\r\n") != -1)
            //替换数据中的两个换行符为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>'”
            {
                parameter = parameter.Replace("\r\n\r\n", " value='");
            }
            else if (parameter.EndsWith("\r\n"))
            //替换数据尾部的换行符为单引号，格式：“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>'”
            {
                parameter = parameter.Replace("\r\n", "'");
            }
            else if (parameter.IndexOf(";") != -1)
            {
                parameter = parameter.Replace(";", " ");
            }
            else if (parameter.IndexOf("''") != -1)
            {
                parameter = parameter.Replace("''", "'");
            }
            else
            {
                return parameter;
            }
            return ProcessCore(parameter);
        }

        #endregion
    }
}

 

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