antissoft / wurenji

  using NCC.Dependency;
  using NCC.Extensions;
  using NCC.UnifyResult;
  using Microsoft.AspNetCore.Http;
  using Microsoft.AspNetCore.Mvc;
  using Microsoft.AspNetCore.Mvc.ActionConstraints;
  using Microsoft.AspNetCore.Mvc.ApplicationModels;
  using Microsoft.AspNetCore.Mvc.ModelBinding;
  using Microsoft.AspNetCore.Mvc.Routing;
  using System;
  using System.Linq;
  using System.Reflection;
  using System.Text.RegularExpressions;
  
  namespace NCC.DynamicApiController
  {
      /// <summary>
      /// 动态接口控制器应用模型转换器
      /// </summary>
      internal sealed class DynamicApiControllerApplicationModelConvention : IApplicationModelConvention
      {
          /// <summary>
          /// 动态接口控制器配置实例
          /// </summary>
          private readonly DynamicApiControllerSettingsOptions _dynamicApiControllerSettings;
  
          /// <summary>
          /// 带版本的名称正则表达式
          /// </summary>
          private readonly Regex _nameVersionRegex;
  
          /// <summary>
          /// 构造函数
          /// </summary>
          public DynamicApiControllerApplicationModelConvention()
          {
              _dynamicApiControllerSettings = App.GetConfig<DynamicApiControllerSettingsOptions>("DynamicApiControllerSettings", true);
              LoadVerbToHttpMethodsConfigure();
              _nameVersionRegex = new Regex(@"V(?<version>[0-9_]+$)");
          }
  
          /// <summary>
          /// 配置应用模型信息
          /// </summary>
          /// <param name="application">引用模型</param>
          public void Apply(ApplicationModel application)
          {
              var controllers = application.Controllers.Where(u => Penetrates.IsApiController(u.ControllerType));
              foreach (var controller in controllers)
              {
                  var controllerType = controller.ControllerType;
  
                  // 判断是否处理 Mvc控制器
                  if (typeof(ControllerBase).IsAssignableFrom(controller.ControllerType))
                  {
                      if (!_dynamicApiControllerSettings.SupportedMvcController.Value || controller.ApiExplorer?.IsVisible == false) continue;
                  }
  
                  var controllerApiDescriptionSettings = controllerType.IsDefined(typeof(ApiDescriptionSettingsAttribute), true) ? controllerType.GetCustomAttribute<ApiDescriptionSettingsAttribute>(true) : default;
                  ConfigureController(controller, controllerApiDescriptionSettings);
              }
          }
  
          /// <summary>
          /// 配置控制器
          /// </summary>
          /// <param name="controller">控制器模型</param>
          /// <param name="controllerApiDescriptionSettings">接口描述配置</param>
          private void ConfigureController(ControllerModel controller, ApiDescriptionSettingsAttribute controllerApiDescriptionSettings)
          {
              // 配置区域
              ConfigureControllerArea(controller, controllerApiDescriptionSettings);
  
              // 配置控制器名称
              ConfigureControllerName(controller, controllerApiDescriptionSettings);
  
              // 存储排序给 Swagger 使用
              Penetrates.ControllerOrderCollection.TryAdd(controller.ControllerName, controllerApiDescriptionSettings?.Order ?? 0);
  
              var actions = controller.Actions;
  
              // 查找所有重复的方法签名
              var repeats = actions.GroupBy(u => new { u.ActionMethod.ReflectedType.Name, Signature = u.ActionMethod.ToString() })
                                   .Where(u => u.Count() > 1)
                                   .SelectMany(u => u.Where(u => u.ActionMethod.ReflectedType.Name != u.ActionMethod.DeclaringType.Name));
  
              // 2021年04月01日 https://docs.microsoft.com/en-US/aspnet/core/web-api/?view=aspnetcore-5.0#binding-source-parameter-inference
              // 判断是否贴有 [ApiController] 特性
              var hasApiControllerAttribute = controller.Attributes.Any(u => u.GetType() == typeof(ApiControllerAttribute));
  
              foreach (var action in actions)
              {
                  // 跳过相同方法签名
                  if (repeats.Contains(action))
                  {
                      action.ApiExplorer.IsVisible = false;
                      continue;
                  };
  
                  var actionMethod = action.ActionMethod;
                  var actionApiDescriptionSettings = actionMethod.IsDefined(typeof(ApiDescriptionSettingsAttribute), true) ? actionMethod.GetCustomAttribute<ApiDescriptionSettingsAttribute>(true) : default;
                  ConfigureAction(action, actionApiDescriptionSettings, controllerApiDescriptionSettings, hasApiControllerAttribute);
              }
          }
  
          /// <summary>
          /// 配置控制器区域
          /// </summary>
          /// <param name="controller"></param>
          /// <param name="controllerApiDescriptionSettings"></param>
          private void ConfigureControllerArea(ControllerModel controller, ApiDescriptionSettingsAttribute controllerApiDescriptionSettings)
          {
              // 如果配置了区域，则跳过
              if (controller.RouteValues.ContainsKey("area")) return;
  
              // 如果没有配置区域，则跳过
              var area = controllerApiDescriptionSettings?.Area ?? _dynamicApiControllerSettings.DefaultArea;
              if (string.IsNullOrWhiteSpace(area)) return;
  
              controller.RouteValues["area"] = area;
          }
  
          /// <summary>
          /// 配置控制器名称
          /// </summary>
          /// <param name="controller">控制器模型</param>
          /// <param name="controllerApiDescriptionSettings">接口描述配置</param>
          private void ConfigureControllerName(ControllerModel controller, ApiDescriptionSettingsAttribute controllerApiDescriptionSettings)
          {
              var (Name, _, _) = ConfigureControllerAndActionName(controllerApiDescriptionSettings, controller.ControllerType.Name, _dynamicApiControllerSettings.AbandonControllerAffixes, _ => _);
              controller.ControllerName = Name;
          }
  
          /// <summary>
          /// 配置动作方法
          /// </summary>
          /// <param name="action">控制器模型</param>
          /// <param name="apiDescriptionSettings">接口描述配置</param>
          /// <param name="controllerApiDescriptionSettings">控制器接口描述配置</param>
          /// <param name="hasApiControllerAttribute">是否贴有 ApiController 特性</param>
          private void ConfigureAction(ActionModel action, ApiDescriptionSettingsAttribute apiDescriptionSettings, ApiDescriptionSettingsAttribute controllerApiDescriptionSettings, bool hasApiControllerAttribute)
          {
              // 配置动作方法接口可见性
              ConfigureActionApiExplorer(action);
  
              // 配置动作方法名称
              var (isLowercaseRoute, isKeepName) = ConfigureActionName(action, apiDescriptionSettings, controllerApiDescriptionSettings);
  
              // 配置动作方法请求谓词特性
              ConfigureActionHttpMethodAttribute(action);
  
              // 配置引用类型参数
              ConfigureClassTypeParameter(action);
  
              // 配置动作方法路由特性
              ConfigureActionRouteAttribute(action, apiDescriptionSettings, controllerApiDescriptionSettings, isLowercaseRoute, isKeepName, hasApiControllerAttribute);
  
              // 配置动作方法规范化特性
              if (UnifyContext.EnabledUnifyHandler) ConfigureActionUnifyResultAttribute(action);
          }
  
          /// <summary>
          /// 配置动作方法接口可见性
          /// </summary>
          /// <param name="action">动作方法模型</param>
          private static void ConfigureActionApiExplorer(ActionModel action)
          {
              if (!action.ApiExplorer.IsVisible.HasValue) action.ApiExplorer.IsVisible = true;
          }
  
          /// <summary>
          /// 配置动作方法名称
          /// </summary>
          /// <param name="action">动作方法模型</param>
          /// <param name="apiDescriptionSettings">接口描述配置</param>
          /// <param name="controllerApiDescriptionSettings"></param>
          /// <returns></returns>
          private (bool IsLowercaseRoute, bool IsKeepName) ConfigureActionName(ActionModel action, ApiDescriptionSettingsAttribute apiDescriptionSettings, ApiDescriptionSettingsAttribute controllerApiDescriptionSettings)
          {
              var (Name, IsLowercaseRoute, IsKeepName) = ConfigureControllerAndActionName(apiDescriptionSettings, action.ActionMethod.Name, _dynamicApiControllerSettings.AbandonActionAffixes, (tempName) =>
              {
                  // 处理动作方法名称谓词
                  if (!CheckIsKeepVerb(apiDescriptionSettings, controllerApiDescriptionSettings))
                  {
                      var words = tempName.SplitCamelCase();
                      var verbKey = words.First().ToLower();
                      // 处理类似 getlist,getall 多个单词
                      if (words.Length > 1 && Penetrates.VerbToHttpMethods.ContainsKey((words[0] + words[1]).ToLower()))
                      {
                          tempName = tempName[(words[0] + words[1]).Length..];
                      }
                      else if (Penetrates.VerbToHttpMethods.ContainsKey(verbKey)) tempName = tempName[verbKey.Length..];
                  }
  
                  return tempName;
              }, controllerApiDescriptionSettings);
              action.ActionName = Name;
  
              return (IsLowercaseRoute, IsKeepName);
          }
  
          /// <summary>
          /// 配置动作方法请求谓词特性
          /// </summary>
          /// <param name="action">动作方法模型</param>
          private void ConfigureActionHttpMethodAttribute(ActionModel action)
          {
              var selectorModel = action.Selectors[0];
              // 跳过已配置请求谓词特性的配置
              if (selectorModel.ActionConstraints.Count > 0) return;
  
              // 解析请求谓词
              var words = action.ActionMethod.Name.SplitCamelCase();
              var verbKey = words.First().ToLower();
  
              // 处理类似 getlist,getall 多个单词
              if (words.Length > 1 && Penetrates.VerbToHttpMethods.ContainsKey((words[0] + words[1]).ToLower()))
              {
                  verbKey = (words[0] + words[1]).ToLower();
              }
  
              var verb = Penetrates.VerbToHttpMethods.ContainsKey(verbKey)
                  ? Penetrates.VerbToHttpMethods[verbKey] ?? _dynamicApiControllerSettings.DefaultHttpMethod.ToUpper()
                  : _dynamicApiControllerSettings.DefaultHttpMethod.ToUpper();
  
              // 添加请求约束
              selectorModel.ActionConstraints.Add(new HttpMethodActionConstraint(new[] { verb }));
  
              // 添加请求谓词特性
              HttpMethodAttribute httpMethodAttribute = verb switch
              {
                  "GET" => new HttpGetAttribute(),
                  "POST" => new HttpPostAttribute(),
                  "PUT" => new HttpPutAttribute(),
                  "DELETE" => new HttpDeleteAttribute(),
                  "PATCH" => new HttpPatchAttribute(),
                  "HEAD" => new HttpHeadAttribute(),
                  _ => throw new NotSupportedException($"{verb}")
              };
  
              selectorModel.EndpointMetadata.Add(httpMethodAttribute);
          }
  
          /// <summary>
          /// 处理类类型参数（添加[FromBody] 特性）
          /// </summary>
          /// <param name="action"></param>
          private void ConfigureClassTypeParameter(ActionModel action)
          {
              // 没有参数无需处理
              if (action.Parameters.Count == 0) return;
  
              // 如果动作方法请求谓词只有GET和HEAD，则将类转查询参数
              if (_dynamicApiControllerSettings.ModelToQuery.Value)
              {
                  var httpMethods = action.Selectors
                      .SelectMany(u => u.ActionConstraints.Where(u => u is HttpMethodActionConstraint)
                          .SelectMany(u => (u as HttpMethodActionConstraint).HttpMethods));
  
                  if (httpMethods.All(u => u.Equals("GET") || u.Equals("HEAD"))) return;
              }
  
              var parameters = action.Parameters;
              foreach (var parameterModel in parameters)
              {
                  // 如果参数已有绑定特性，则跳过
                  if (parameterModel.BindingInfo != null) continue;
  
                  var parameterType = parameterModel.ParameterType;
                  // 如果是基元类型，则跳过
                  if (parameterType.IsRichPrimitive()) continue;
  
                  // 如果是文件类型，则跳过
                  if (typeof(IFormFile).IsAssignableFrom(parameterType) || typeof(IFormFileCollection).IsAssignableFrom(parameterType)) continue;
  
                  parameterModel.BindingInfo = BindingInfo.GetBindingInfo(new[] { new FromBodyAttribute() });
              }
          }
  
          /// <summary>
          /// 配置动作方法路由特性
          /// </summary>
          /// <param name="action">动作方法模型</param>
          /// <param name="apiDescriptionSettings">接口描述配置</param>
          /// <param name="controllerApiDescriptionSettings">控制器接口描述配置</param>
          /// <param name="isLowercaseRoute"></param>
          /// <param name="isKeepName"></param>
          /// <param name="hasApiControllerAttribute"></param>
          private void ConfigureActionRouteAttribute(ActionModel action, ApiDescriptionSettingsAttribute apiDescriptionSettings, ApiDescriptionSettingsAttribute controllerApiDescriptionSettings, bool isLowercaseRoute, bool isKeepName, bool hasApiControllerAttribute)
          {
              var selectorModel = action.Selectors[0];
              // 跳过已配置路由特性的配置
              if (selectorModel.AttributeRouteModel != null) return;
  
              // 读取模块
              var module = apiDescriptionSettings?.Module;
  
              string template;
              string controllerRouteTemplate = null;
              // 如果动作方法名称为空、参数值为空，且无需保留谓词，则只生成控制器路由模板
              if (action.ActionName.Length == 0 && !isKeepName && action.Parameters.Count == 0)
              {
                  template = GenerateControllerRouteTemplate(action.Controller, controllerApiDescriptionSettings);
              }
              else
              {
                  // 生成参数路由模板
                  var parameterRouteTemplate = GenerateParameterRouteTemplates(action, isLowercaseRoute, hasApiControllerAttribute);
  
                  // 生成控制器模板
                  controllerRouteTemplate = GenerateControllerRouteTemplate(action.Controller, controllerApiDescriptionSettings, parameterRouteTemplate);
  
                  // 拼接动作方法路由模板
                  var ActionStartTemplate = parameterRouteTemplate != null ? (parameterRouteTemplate.ActionStartTemplates.Count == 0 ? null : string.Join("/", parameterRouteTemplate.ActionStartTemplates)) : null;
                  var ActionEndTemplate = parameterRouteTemplate != null ? (parameterRouteTemplate.ActionEndTemplates.Count == 0 ? null : string.Join("/", parameterRouteTemplate.ActionEndTemplates)) : null;
  
                  // 判断是否定义了控制器路由，如果定义，则不拼接控制器路由
                  template = string.IsNullOrWhiteSpace(controllerRouteTemplate)
                       ? $"{(string.IsNullOrWhiteSpace(module) ? "/" : $"{module}/")}{ActionStartTemplate}/{(string.IsNullOrWhiteSpace(action.ActionName) ? null : "[action]")}/{ActionEndTemplate}"
                       : $"{controllerRouteTemplate}/{(string.IsNullOrWhiteSpace(module) ? null : $"{module}/")}{ActionStartTemplate}/{(string.IsNullOrWhiteSpace(action.ActionName) ? null : "[action]")}/{ActionEndTemplate}";
              }
  
              AttributeRouteModel actionAttributeRouteModel = null;
              if (!string.IsNullOrWhiteSpace(template))
              {
                  // 处理多个斜杆问题
                  template = Regex.Replace(isLowercaseRoute ? template.ToLower() : template, @"\/{2,}", "/");
  
                  // 生成路由
                  actionAttributeRouteModel = string.IsNullOrWhiteSpace(template) ? null : new AttributeRouteModel(new RouteAttribute(template));
              }
  
              // 拼接路由
              selectorModel.AttributeRouteModel = string.IsNullOrWhiteSpace(controllerRouteTemplate)
                  ? (actionAttributeRouteModel == null ? null : AttributeRouteModel.CombineAttributeRouteModel(action.Controller.Selectors[0].AttributeRouteModel, actionAttributeRouteModel))
                  : actionAttributeRouteModel;
          }
  
          /// <summary>
          /// 生成控制器路由模板
          /// </summary>
          /// <param name="controller"></param>
          /// <param name="apiDescriptionSettings"></param>
          /// <param name="parameterRouteTemplate">参数路由模板</param>
          /// <returns></returns>
          private string GenerateControllerRouteTemplate(ControllerModel controller, ApiDescriptionSettingsAttribute apiDescriptionSettings, ParameterRouteTemplate parameterRouteTemplate = default)
          {
              var selectorModel = controller.Selectors[0];
              // 跳过已配置路由特性的配置
              if (selectorModel.AttributeRouteModel != null) return default;
  
              // 读取模块
              var module = apiDescriptionSettings?.Module ?? _dynamicApiControllerSettings.DefaultModule;
  
              // 路由默认前缀
              var routePrefix = _dynamicApiControllerSettings.DefaultRoutePrefix;
  
              // 生成路由模板
              // 如果参数路由模板为空或不包含任何控制器参数模板，则返回正常的模板
              if (parameterRouteTemplate == null || (parameterRouteTemplate.ControllerStartTemplates.Count == 0 && parameterRouteTemplate.ControllerEndTemplates.Count == 0))
                  return $"{(string.IsNullOrWhiteSpace(routePrefix) ? null : $"{routePrefix}/")}{(string.IsNullOrWhiteSpace(module) ? null : $"{module}/")}[controller]";
  
              // 拼接控制器路由模板
              var controllerStartTemplate = parameterRouteTemplate.ControllerStartTemplates.Count == 0 ? null : string.Join("/", parameterRouteTemplate.ControllerStartTemplates);
              var controllerEndTemplate = parameterRouteTemplate.ControllerEndTemplates.Count == 0 ? null : string.Join("/", parameterRouteTemplate.ControllerEndTemplates);
              var template = $"{(string.IsNullOrWhiteSpace(routePrefix) ? null : $"{routePrefix}/")}{(string.IsNullOrWhiteSpace(module) ? null : $"{module}/")}{controllerStartTemplate}/[controller]/{controllerEndTemplate}";
  
              return template;
          }
  
          /// <summary>
          /// 生成参数路由模板（非引用类型）
          /// </summary>
          /// <param name="action">动作方法模型</param>
          /// <param name="isLowercaseRoute"></param>
          /// <param name="hasApiControllerAttribute"></param>
          private ParameterRouteTemplate GenerateParameterRouteTemplates(ActionModel action, bool isLowercaseRoute, bool hasApiControllerAttribute)
          {
              // 如果没有参数，则跳过
              if (action.Parameters.Count == 0) return default;
  
              var parameterRouteTemplate = new ParameterRouteTemplate();
              var parameters = action.Parameters;
  
              // 判断是否贴有 [QueryParameters] 特性
              var isQueryParametersAction = action.Attributes.Any(u => u is QueryParametersAttribute);
  
              // 遍历所有参数
              foreach (var parameterModel in parameters)
              {
                  var parameterType = parameterModel.ParameterType;
                  var parameterAttributes = parameterModel.Attributes;
  
                  // 处理小写参数路由匹配问题
                  if (isLowercaseRoute) parameterModel.ParameterName = parameterModel.ParameterName.ToLower();
  
                  // 判断是否贴有任何 [FromXXX] 特性了
                  var hasFormAttribute = parameterAttributes.Any(u => typeof(IBindingSourceMetadata).IsAssignableFrom(u.GetType()));
  
                  // 判断方法贴有 [QueryParameters] 特性且当前参数没有任何 [FromXXX] 特性，则添加 [FromQuery] 特性
                  if (isQueryParametersAction && !hasFormAttribute)
                  {
                      parameterModel.BindingInfo = BindingInfo.GetBindingInfo(new[] { new FromQueryAttribute() });
                      continue;
                  }
  
                  // 如果没有贴 [FromRoute] 特性且不是基元类型，则跳过
                  // 如果没有贴 [FromRoute] 特性且有任何绑定特性，则跳过
                  if (!parameterAttributes.Any(u => u is FromRouteAttribute)
                      && (!parameterType.IsRichPrimitive() || hasFormAttribute)) continue;
  
                  // 处理基元数组数组类型，还有全局配置参数问题
                  if (_dynamicApiControllerSettings?.UrlParameterization == true || parameterType.IsArray)
                  {
                      parameterModel.BindingInfo = BindingInfo.GetBindingInfo(new[] { new FromQueryAttribute() });
                      continue;
                  }
  
                  // 处理 [ApiController] 特性情况
                  // https://docs.microsoft.com/en-US/aspnet/core/web-api/?view=aspnetcore-5.0#binding-source-parameter-inference
                  if (!hasFormAttribute && hasApiControllerAttribute) continue;
  
                  // 判断是否可以为null
                  var canBeNull = parameterType.IsGenericType && parameterType.GetGenericTypeDefinition() == typeof(Nullable<>);
  
                  // 判断是否贴有路由约束特性
                  string constraint = default;
                  if (parameterAttributes.FirstOrDefault(u => u is RouteConstraintAttribute) is RouteConstraintAttribute routeConstraint && !string.IsNullOrWhiteSpace(routeConstraint.Constraint))
                  {
                      constraint = !routeConstraint.Constraint.StartsWith(":")
                          ? $":{routeConstraint.Constraint}" : routeConstraint.Constraint;
                  }
  
                  var template = $"{{{parameterModel.ParameterName}{(canBeNull ? "?" : string.Empty)}{constraint}}}";
                  // 如果没有贴路由位置特性，则默认添加到动作方法后面
                  if (parameterAttributes.FirstOrDefault(u => u is ApiSeatAttribute) is not ApiSeatAttribute apiSeat)
                  {
                      parameterRouteTemplate.ActionEndTemplates.Add(template);
                      continue;
                  }
  
                  // 生成路由参数位置
                  switch (apiSeat.Seat)
                  {
                      // 控制器名之前
                      case ApiSeats.ControllerStart:
                          parameterRouteTemplate.ControllerStartTemplates.Add(template);
                          break;
                      // 控制器名之后
                      case ApiSeats.ControllerEnd:
                          parameterRouteTemplate.ControllerEndTemplates.Add(template);
                          break;
                      // 动作方法名之前
                      case ApiSeats.ActionStart:
                          parameterRouteTemplate.ActionStartTemplates.Add(template);
                          break;
                      // 动作方法名之后
                      case ApiSeats.ActionEnd:
                          parameterRouteTemplate.ActionEndTemplates.Add(template);
                          break;
  
                      default: break;
                  }
              }
  
              return parameterRouteTemplate;
          }
  
          /// <summary>
          /// 配置控制器和动作方法名称
          /// </summary>
          /// <param name="apiDescriptionSettings"></param>
          /// <param name="orignalName"></param>
          /// <param name="affixes"></param>
          /// <param name="configure"></param>
          /// <param name="controllerApiDescriptionSettings"></param>
          /// <returns></returns>
          private (string Name, bool IsLowercaseRoute, bool IsKeepName) ConfigureControllerAndActionName(ApiDescriptionSettingsAttribute apiDescriptionSettings, string orignalName, string[] affixes, Func<string, string> configure, ApiDescriptionSettingsAttribute controllerApiDescriptionSettings = default)
          {
              // 获取版本号
              var apiVersion = apiDescriptionSettings?.Version;
              var isKeepName = false;
  
              // 解析控制器名称
              // 判断是否有自定义名称
              var tempName = apiDescriptionSettings?.Name;
              if (string.IsNullOrWhiteSpace(tempName))
              {
                  // 处理版本号
                  var (name, version) = ResolveNameVersion(orignalName);
                  tempName = name;
                  apiVersion ??= version;
  
                  // 清除指定前后缀
                  tempName = tempName.ClearStringAffixes(affixes: affixes);
  
                  isKeepName = CheckIsKeepName(controllerApiDescriptionSettings == null ? null : apiDescriptionSettings, controllerApiDescriptionSettings ?? apiDescriptionSettings);
  
                  // 判断是否保留原有名称
                  if (!isKeepName)
                  {
                      // 自定义配置
                      tempName = configure.Invoke(tempName);
  
                      // 处理骆驼命名
                      if (CheckIsSplitCamelCase(controllerApiDescriptionSettings == null ? null : apiDescriptionSettings, controllerApiDescriptionSettings ?? apiDescriptionSettings))
                      {
                          tempName = string.Join(_dynamicApiControllerSettings.CamelCaseSeparator, tempName.SplitCamelCase());
                      }
                  }
              }
  
              // 拼接名称和版本号
              var newName = $"{tempName}{(string.IsNullOrWhiteSpace(apiVersion) ? null : $"{_dynamicApiControllerSettings.VersionSeparator}{apiVersion}")}";
  
              var isLowercaseRoute = CheckIsLowercaseRoute(controllerApiDescriptionSettings == null ? null : apiDescriptionSettings, controllerApiDescriptionSettings ?? apiDescriptionSettings);
              return (isLowercaseRoute ? newName.ToLower() : newName, isLowercaseRoute, isKeepName);
          }
  
          /// <summary>
          /// 检查是否设置了 KeepName参数
          /// </summary>
          /// <param name="apiDescriptionSettings"></param>
          /// <param name="controllerApiDescriptionSettings"></param>
          /// <returns></returns>
          private bool CheckIsKeepName(ApiDescriptionSettingsAttribute apiDescriptionSettings, ApiDescriptionSettingsAttribute controllerApiDescriptionSettings)
          {
              bool isKeepName;
  
              // 判断 Action 是否配置了 KeepName 属性
              if (apiDescriptionSettings?.KeepName != null)
              {
                  var canParse = bool.TryParse(apiDescriptionSettings.KeepName.ToString(), out var value);
                  isKeepName = canParse && value;
              }
              // 判断 Controller 是否配置了 KeepName 属性
              else if (controllerApiDescriptionSettings?.KeepName != null)
              {
                  var canParse = bool.TryParse(controllerApiDescriptionSettings.KeepName.ToString(), out var value);
                  isKeepName = canParse && value;
              }
              // 取全局配置
              else isKeepName = _dynamicApiControllerSettings?.KeepName == true;
  
              return isKeepName;
          }
  
          /// <summary>
          /// 检查是否设置了 KeepVerb 参数
          /// </summary>
          /// <param name="apiDescriptionSettings"></param>
          /// <param name="controllerApiDescriptionSettings"></param>
          /// <returns></returns>
          private bool CheckIsKeepVerb(ApiDescriptionSettingsAttribute apiDescriptionSettings, ApiDescriptionSettingsAttribute controllerApiDescriptionSettings)
          {
              bool isKeepVerb;
  
              // 判断 Action 是否配置了 KeepVerb 属性
              if (apiDescriptionSettings?.KeepVerb != null)
              {
                  var canParse = bool.TryParse(apiDescriptionSettings.KeepVerb.ToString(), out var value);
                  isKeepVerb = canParse && value;
              }
              // 判断 Controller 是否配置了 KeepVerb 属性
              else if (controllerApiDescriptionSettings?.KeepVerb != null)
              {
                  var canParse = bool.TryParse(controllerApiDescriptionSettings.KeepVerb.ToString(), out var value);
                  isKeepVerb = canParse && value;
              }
              // 取全局配置
              else isKeepVerb = _dynamicApiControllerSettings?.KeepVerb == true;
  
              return isKeepVerb;
          }
  
          /// <summary>
          /// 判断切割命名参数是否配置
          /// </summary>
          /// <param name="apiDescriptionSettings"></param>
          /// <param name="controllerApiDescriptionSettings"></param>
          /// <returns></returns>
          private static bool CheckIsSplitCamelCase(ApiDescriptionSettingsAttribute apiDescriptionSettings, ApiDescriptionSettingsAttribute controllerApiDescriptionSettings)
          {
              bool isSplitCamelCase;
  
              // 判断 Action 是否配置了 SplitCamelCase 属性
              if (apiDescriptionSettings?.SplitCamelCase != null)
              {
                  var canParse = bool.TryParse(apiDescriptionSettings.SplitCamelCase.ToString(), out var value);
                  isSplitCamelCase = !canParse || value;
              }
              // 判断 Controller 是否配置了 SplitCamelCase 属性
              else if (controllerApiDescriptionSettings?.SplitCamelCase != null)
              {
                  var canParse = bool.TryParse(controllerApiDescriptionSettings.SplitCamelCase.ToString(), out var value);
                  isSplitCamelCase = !canParse || value;
              }
              // 取全局配置
              else isSplitCamelCase = true;
  
              return isSplitCamelCase;
          }
  
          /// <summary>
          /// 检查是否启用小写路由
          /// </summary>
          /// <param name="apiDescriptionSettings"></param>
          /// <param name="controllerApiDescriptionSettings"></param>
          /// <returns></returns>
          private bool CheckIsLowercaseRoute(ApiDescriptionSettingsAttribute apiDescriptionSettings, ApiDescriptionSettingsAttribute controllerApiDescriptionSettings)
          {
              bool isLowercaseRoute;
  
              // 判断 Action 是否配置了 LowercaseRoute 属性
              if (apiDescriptionSettings?.LowercaseRoute != null)
              {
                  var canParse = bool.TryParse(apiDescriptionSettings.LowercaseRoute.ToString(), out var value);
                  isLowercaseRoute = !canParse || value;
              }
              // 判断 Controller 是否配置了 LowercaseRoute 属性
              else if (controllerApiDescriptionSettings?.LowercaseRoute != null)
              {
                  var canParse = bool.TryParse(controllerApiDescriptionSettings.LowercaseRoute.ToString(), out var value);
                  isLowercaseRoute = !canParse || value;
              }
              // 取全局配置
              else isLowercaseRoute = (_dynamicApiControllerSettings?.LowercaseRoute) != false;
  
              return isLowercaseRoute;
          }
  
          /// <summary>
          /// 配置规范化结果类型
          /// </summary>
          /// <param name="action"></param>
          private static void ConfigureActionUnifyResultAttribute(ActionModel action)
          {
              // 判断是否手动添加了标注或跳过规范化处理
              if (UnifyContext.CheckSucceededNonUnify(action.ActionMethod, out var _, false)) return;
  
              // 获取真实类型
              var returnType = action.ActionMethod.GetRealReturnType();
              if (returnType == typeof(void)) return;
  
              // 添加规范化结果特性
              action.Filters.Add(new UnifyResultAttribute(returnType, StatusCodes.Status200OK));
          }
  
          /// <summary>
          /// 解析名称中的版本号
          /// </summary>
          /// <param name="name">名称</param>
          /// <returns>名称和版本号</returns>
          private (string name, string version) ResolveNameVersion(string name)
          {
              if (!_nameVersionRegex.IsMatch(name)) return (name, default);
  
              var version = _nameVersionRegex.Match(name).Groups["version"].Value.Replace("_", ".");
              return (_nameVersionRegex.Replace(name, ""), version);
          }
  
          /// <summary>
          /// 获取方法名映射 [HttpMethod] 规则
          /// </summary>
          /// <returns></returns>
          private void LoadVerbToHttpMethodsConfigure()
          {
              var defaultVerbToHttpMethods = Penetrates.VerbToHttpMethods;
  
              // 获取配置的复写映射规则
              var verbToHttpMethods = _dynamicApiControllerSettings.VerbToHttpMethods;
  
              if (verbToHttpMethods is not null)
              {
                  // 获取所有参数大于1的配置
                  var settingsVerbToHttpMethods = verbToHttpMethods
                      .Where(u => u.Length > 1)
                      .ToDictionary(u => u[0].ToString().ToLower(), u => u[1]?.ToString());
  
                  defaultVerbToHttpMethods.AddOrUpdate(settingsVerbToHttpMethods);
              }
          }
      }
  }