qidao123.com技术社区-IT企服评测·应用市场

标题: 如何优雅地让 ASP.NET Core 支持异步模子验证 [打印本页]
作者: 羊蹓狼    时间: 2024-12-16 11:00
标题: 如何优雅地让 ASP.NET Core 支持异步模子验证
前言

在ASP.NET Core官方仓库中有个不绝很受关注的问题Please reconsider allowing async model validation。FluentValidation的作者也非常关心这个问题，因为FluentValidation内置异步验证功能，但是由于MVC内置的模子验证管道是同步的，使可兼容的功能和集成都受到严重阻碍。每次MVC修改验证功能都有可能导致集成出问题。
不仅如此，FluentValidation固然是一个优秀的对象验证库，但其实现方式照旧导致了一些与ASP.NET Core集成上的问题。例如他的验证消息当地化功能是通过全局对象管理的，这导致想要把消息当地化和依靠注入集成在一起的方式非常别扭。
最近在问题的评论中发现了一个复制并修改原始模子绑定体系得到的异步模子验证服务。这个修改版看上去照旧比较直观的，利用自定义模子绑定器更换内置绑定器，然后用自定义的异步验证服务更换内置验证服务。同时提供了配套的异步验证特性和异步验证器助手。
但是利用过程中照旧发现了一些不尽如人意的地方：
总之就是无论如何都感觉别扭。因此笔者基于原始的改造重写了一个新版以期解决以上问题。
新书宣传

有关新书的更多先容欢迎查看《C#与.NET6 开辟从入门到实践》上市，作者亲自来打广告了！

正文

异步模子验证

解决第一个问题，起首就是分离基本验证器和MVC集成的类到不同项目，因此基本验证器的相关内容放到CoreDX.Extensions.Validation中，MVC相关的内容放到CoreDX.Extensions.AspNetCore.Validation中。
解决第二个问题则是简单的根据原版验证特性重新按套路添加异步方法。
AsyncValidationAttribute
  1. public abstract class AsyncValidationAttribute : ValidationAttribute
  2. {
  3.     private volatile bool _hasBaseIsValidAsync;
  5.     protected override sealed ValidationResult? IsValid(object? value, ValidationContext validationContext)
  6.     {
  7.         throw new InvalidOperationException("Async validation called synchronously.");
  8.     }
  10.     public override sealed bool IsValid(object? value)
  11.     {
  12.         throw new InvalidOperationException("Async validation called synchronously.");
  13.     }
  15.     public virtual async ValueTask<bool> IsValidAsync(object? value, CancellationToken cancellationToken = default)
  16.     {
  17.         if (!_hasBaseIsValidAsync)
  18.         {
  19.             // track that this method overload has not been overridden.
  20.             _hasBaseIsValidAsync = true;
  21.         }
  23.         // call overridden method.
  24.         // The IsValid method without a validationContext predates the one accepting the context.
  25.         // This is theoretically unreachable through normal use cases.
  26.         // Instead, the overload using validationContext should be called.
  27.         return await IsValidAsync(value, null!, cancellationToken: cancellationToken) == ValidationResult.Success;
  28.     }
  30.     protected virtual async ValueTask<ValidationResult?> IsValidAsync(object? value, ValidationContext validationContext, CancellationToken cancellationToken = default)
  31.     {
  32.         if (_hasBaseIsValidAsync)
  33.         {
  34.             // this means neither of the IsValidAsync methods has been overridden, throw.
  35.             throw new NotImplementedException("IsValidAsync(object value, CancellationToken cancellationToken) has not been implemented by this class.  The preferred entry point is GetValidationResultAsync() and classes should override IsValidAsync(object value, ValidationContext context, CancellationToken cancellationToken).");
  36.         }
  38.         // call overridden method.
  39.         return await IsValidAsync(value, cancellationToken)
  40.             ? ValidationResult.Success
  41.             : CreateFailedValidationResult(validationContext);
  42.     }
  44.     public async ValueTask<ValidationResult?> GetValidationResultAsync(object? value, ValidationContext validationContext, CancellationToken cancellationToken = default)
  45.     {
  46.         if (validationContext == null)
  47.         {
  48.             throw new ArgumentNullException(nameof(validationContext));
  49.         }
  51.         ValidationResult? result = await IsValidAsync(value, validationContext, cancellationToken);
  53.         // If validation fails, we want to ensure we have a ValidationResult that guarantees it has an ErrorMessage
  54.         if (result != null)
  55.         {
  56.             if (string.IsNullOrEmpty(result.ErrorMessage))
  57.             {
  58.                 var errorMessage = FormatErrorMessage(validationContext.DisplayName);
  59.                 result = new ValidationResult(errorMessage, result?.MemberNames);
  60.             }
  61.         }
  63.         return result;
  64.     }
  66.     public async ValueTask ValidateAsync(object? value, string name, CancellationToken cancellationToken = default)
  67.     {
  68.         if (!(await IsValidAsync(value, cancellationToken)))
  69.         {
  70.             throw new ValidationException(FormatErrorMessage(name), this, value);
  71.         }
  72.     }
  74.     public async ValueTask ValidateAsync(object? value, ValidationContext validationContext, CancellationToken cancellationToken = default)
  75.     {
  76.         if (validationContext == null)
  77.         {
  78.             throw new ArgumentNullException(nameof(validationContext));
  79.         }
  81.         ValidationResult? result = await GetValidationResultAsync(value, validationContext, cancellationToken: cancellationToken);
  83.         if (result != null)
  84.         {
  85.             // Convenience -- if implementation did not fill in an error message,
  86.             throw new ValidationException(result, this, value);
  87.         }
  88.     }
  89. }
复制代码
基本思绪就是继承原版验证特性，密封原版验证方法抛出异常，添加对应的异步验证方法。同时笔者也添加了对应的自定义异步验证特性CustomAsyncValidationAttribute，代码较多，基本思绪也没变，感兴趣的可以查看仓库代码CustomAsyncValidationAttribute.cs。当然用于直接在类型上实现验证功能的接口IValidatableObject也添加了对应的异步版本IAsyncValidatableObject，做戏做全套嘛。
然后就是实现对应的异步验证器，方法也非常简单，复制原版验证器的代码，把所有必要的方法改为异步方法，在内部添加对平凡同步验证特性和异步验证特性的分别处理惩罚，末了加上自定义新接口的支持部门就大功告成了。详细代码可以查看AsyncValidator.cs。
根据命名规范，如果一个类型是明确的异步专用类型，内部的方法可以不利用Async后缀，例如Task类中的方法，因此笔者利用没有后缀的方法名，也方便修改利用验证器的代码，只必要修改类型便可。
解决第三个问题的关键是IModelValidator接口的实现，评论提供的代码直接抛出异常，非常粗暴，因此这里直接修改成返回空白结果集即可。为了配合异步验证，添加一个新接口IAsyncModelValidator实现IModelValidator并添加对应的异步方法，实现同步接口的原因是为了能顺利注册到MVC框架中。这一套下来必要重新实现十个左右的服务，代码量较大，和原版服务的区别也仅限于同步和异步，因此不再展示，感兴趣的朋侪可以查看仓库代码CoreDX.Extensions.AspNetCore.Validation。
其中值得关注的一点是，复刻版DefaultComplexObjectValidationStrategy必要利用ModelMetadata的内部成员，只能反射。好在 .NET8.0 添加了一个专门用来简化静态反射的功能，可以用起来简化代码提高性能。
  1. #if NET8_0_OR_GREATER
  2.     [UnsafeAccessor(UnsafeAccessorKind.Method, Name = nameof(ThrowIfRecordTypeHasValidationOnProperties))]
  3.     internal extern static void ThrowIfRecordTypeHasValidationOnProperties(ModelMetadata modelMetadata);
  5.     [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_BoundProperties")]
  6.     internal extern static IReadOnlyList<ModelMetadata> GetBoundProperties(ModelMetadata modelMetadata);
  8.     [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_BoundConstructorParameterMapping")]
  9.     internal extern static IReadOnlyDictionary<ModelMetadata, ModelMetadata> GetBoundConstructorParameterMapping(ModelMetadata modelMetadata);
  10. #endif
复制代码
末了在为服务注册和手动重新验证添加相应的辅助方法，即可正常利用。此时如果继续利用同步的手动模子验证，固然不会发生异常，但是异步验证特性也会被忽略。
MVC异步模子验证服务注册扩展
  1. namespace Microsoft.AspNetCore.Mvc;
  3. public static class AsyncValidationExtension
  4. {
  5.     public static IMvcBuilder AddAsyncDataAnnotations(this IMvcBuilder builder)
  6.     {
  7.         builder.Services.AddSingleton<IConfigureOptions<MvcOptions>, ConfigureMvcOptionsSetup>();
  8.         builder.Services.AddSingleton<ParameterBinder, AsyncParamterBinder>();
  9.         builder.Services.TryAddSingleton<IAsyncObjectModelValidator>(s =>
  10.         {
  11.             var options = s.GetRequiredService<IOptions<MvcOptions>>().Value;
  12.             var metadataProvider = s.GetRequiredService<IModelMetadataProvider>();
  13.             return new DefaultAsyncObjecValidator(metadataProvider, options.ModelValidatorProviders, options);
  14.         });
  15.         return builder;
  16.     }
  18.     public static IMvcCoreBuilder AddAsyncDataAnnotations(this IMvcCoreBuilder builder)
  19.     {
  20.         builder.Services.AddSingleton<IConfigureOptions<MvcOptions>, ConfigureMvcOptionsSetup>();
  21.         builder.Services.AddSingleton<ParameterBinder, AsyncParamterBinder>();
  22.         builder.Services.TryAddSingleton<IAsyncObjectModelValidator>(s =>
  23.         {
  24.             var options = s.GetRequiredService<IOptions<MvcOptions>>().Value;
  25.             var cache = s.GetRequiredService<ValidatorCache>();
  26.             var metadataProvider = s.GetRequiredService<IModelMetadataProvider>();
  27.             return new DefaultAsyncObjecValidator(metadataProvider, options.ModelValidatorProviders, options);
  28.         });
  29.         return builder;
  30.     }
  32.     internal sealed class ConfigureMvcOptionsSetup : IConfigureOptions<MvcOptions>
  33.     {
  34.         private readonly IStringLocalizerFactory? _stringLocalizerFactory;
  35.         private readonly IValidationAttributeAdapterProvider _validationAttributeAdapterProvider;
  36.         private readonly IOptions<MvcDataAnnotationsLocalizationOptions> _dataAnnotationLocalizationOptions;
  38.         public ConfigureMvcOptionsSetup(
  39.             IValidationAttributeAdapterProvider validationAttributeAdapterProvider,
  40.             IOptions<MvcDataAnnotationsLocalizationOptions> dataAnnotationLocalizationOptions)
  41.         {
  42.             ArgumentNullException.ThrowIfNull(validationAttributeAdapterProvider);
  43.             ArgumentNullException.ThrowIfNull(dataAnnotationLocalizationOptions);
  45.             _validationAttributeAdapterProvider = validationAttributeAdapterProvider;
  46.             _dataAnnotationLocalizationOptions = dataAnnotationLocalizationOptions;
  47.         }
  49.         public ConfigureMvcOptionsSetup(
  50.             IValidationAttributeAdapterProvider validationAttributeAdapterProvider,
  51.             IOptions<MvcDataAnnotationsLocalizationOptions> dataAnnotationLocalizationOptions,
  52.             IStringLocalizerFactory stringLocalizerFactory)
  53.             : this(validationAttributeAdapterProvider, dataAnnotationLocalizationOptions)
  54.         {
  55.             _stringLocalizerFactory = stringLocalizerFactory;
  56.         }
  58.         public void Configure(MvcOptions options)
  59.         {
  60.             ArgumentNullException.ThrowIfNull(options);
  62.             options.ModelValidatorProviders.Insert(0, new AsyncDataAnnotationsModelValidatorProvider(
  63.                 _validationAttributeAdapterProvider,
  64.                 _dataAnnotationLocalizationOptions,
  65.                 _stringLocalizerFactory));
  67.             options.ModelValidatorProviders.Insert(0, new DefaultAsyncModelValidatorProvider());
  68.         }
  69.     }
  70. }
  72. public static class AsyncValidatiorExtension
  73. {
  74.     public static Task<bool> TryValidateModelAsync(
  75.         this ControllerBase controller,
  76.         object model,
  77.         CancellationToken cancellationToken = default)
  78.     {
  79.         return TryValidateModelAsync(controller, model, null, cancellationToken);
  80.     }
  82.     public static async Task<bool> TryValidateModelAsync(
  83.         this ControllerBase controller,
  84.         object model,
  85.         string? prefix,
  86.         CancellationToken cancellationToken = default)
  87.     {
  88.         await TryValidateModelAsync(
  89.             controller.ControllerContext,
  90.             model: model,
  91.             prefix: prefix ?? string.Empty,
  92.             cancellationToken);
  94.         return controller.ModelState.IsValid;
  95.     }
  97.     public static Task<bool> TryValidateModelAsync(
  98.         this PageModel page,
  99.         object model,
  100.         CancellationToken cancellationToken = default)
  101.     {
  102.         return TryValidateModelAsync(page, model, null, cancellationToken);
  103.     }
  105.     public static async Task<bool> TryValidateModelAsync(
  106.         this PageModel page,
  107.         object model,
  108.         string? prefix,
  109.         CancellationToken cancellationToken = default)
  110.     {
  111.         await TryValidateModelAsync(
  112.             page.PageContext,
  113.             model: model,
  114.             prefix: prefix ?? string.Empty,
  115.             cancellationToken);
  117.         return page.ModelState.IsValid;
  118.     }
  120.     private static Task TryValidateModelAsync(
  121.         ActionContext context,
  122.         object model,
  123.         string? prefix,
  124.         CancellationToken cancellationToken = default)
  125.     {
  126.         ArgumentNullException.ThrowIfNull(context);
  127.         ArgumentNullException.ThrowIfNull(model);
  129.         var validator = context.HttpContext.RequestServices.GetRequiredService<IAsyncObjectModelValidator>();
  131.         return validator.ValidateAsync(
  132.             context,
  133.             validationState: null,
  134.             prefix: prefix ?? string.Empty,
  135.             model: model,
  136.             cancellationToken);
  137.     }
  138. }
复制代码
对象图递归验证

终于来到了末了一个问题，这个其实才是最困难的。Nuget上有一些别人写的递归验证器，但是笔者查看过代码和issues后发现这些验证器都有这样那样的问题。起首这些验证器都不支持异步验证，而且笔者有自己的异步验证基础类，就算这些验证器支持异步验证也和笔者提供的类型不兼容；其次这些验证器的API形状和内部运行机制没有完全对齐官方版本，这也意味动手动拆包对象后用官方验证器出来的结果可能对不上；再次这些验证器都存在没有解决的issue；作者也基本弃坑了。末了照旧只能自己写一个。
在 Blazor 中曾经有一个实验性的递归表单模子验证器。但是这个验证器起首只能在 Blazor 中利用，其次必要一个专用特性表示模子的某个属性是复杂对象类型，必要继续深入验证他的内部属性，这种实现方式又会导致如果某个属性本身不必要验证，但内部的其他属性必要验证，就要链式地为整个属性链全部标记这个特性。这种半自动的用法照旧不太方便。如果这个类型的源代码不归自己管无法修改，那就彻底没戏了。
在参考了这个已经不存在的表单验证器后，笔者实现了第一版对象图验证器，但是调试时发现一个极其贫苦的问题，循环引用对象的自动短路无论如何体现的都非常奇怪。要么是某些对象没有被验证，要么是某些对象被验证两次，要么干脆直接栈溢出，怎么调解短路条件都不对。而且此时还只是实现了同步验证，如果要再加上异步验证，肯定会变成一个更贫苦的问题。
多次实验无果后只能重新整理思绪和代码。皇天不负故意人，在将近半个月的摸索后终于灵光一闪，想通了问题的关键。一语道破的一行代码写完后，一切终于如预期一样工作，乃至验证结果的出现顺序都和预想的完全同等。完成这个全自动对象图验证器后，最小API之类的其他场景也终于可以像MVC一样用验证特性验证整个对象模子了。而且这个验证器位于基础功能包，不依靠ASP.NET Core，可以在任意 .NET 项目中利用。
整个验证类代码较多，凌驾两千行，API形状和基础行为和官方验证器保持同等（笔者查看过的其他验证器代码基本在500行以内，几乎无法避免存在缺陷），因此只展示一下关键部门，完备代码请查看仓库ObjectGraphValidation。
  1. private static bool TryValidateObjectRecursive(
  2.     object instance,
  3.     ValidationContext validationContext,
  4.     ValidationResultStore? validationResults,
  5.     AsyncValidationBehavior asyncValidationBehavior,
  6.     bool validateAllProperties,
  7.     Func<Type, bool>? predicate,
  8.     bool throwOnFirstError)
  9. {
  10.     if (instance == null)
  11.     {
  12.         throw new ArgumentNullException(nameof(instance));
  13.     }
  14.     if (validationContext == null)
  15.     {
  16.         throw new ArgumentNullException(nameof(validationContext));
  17.     }
  18.     if (instance != validationContext.ObjectInstance)
  19.     {
  20.         throw new ArgumentException("The instance provided must match the ObjectInstance on the ValidationContext supplied.", nameof(instance));
  21.     }
  23.     // 这里就是关键，只要在这里记录访问历史，一切都会好起来的
  24.     if (!(validationContext.Items.TryGetValue(_validatedObjectsKey, out var item)
  25.         && item is HashSet<object> visited
  26.         && visited.Add(instance)))
  27.     {
  28.         return true;
  29.     }
  31.     bool isValid = true;
  32.     bool breakOnFirstError = (validationResults == null);
  34.     foreach (ValidationError err in GetObjectValidationErrors(
  35.         instance,
  36.         validationContext,
  37.         asyncValidationBehavior,
  38.         validateAllProperties,
  39.         breakOnFirstError))
  40.     {
  41.         if (throwOnFirstError) err.ThrowValidationException();
  43.         isValid = false;
  45.         if (breakOnFirstError) break;
  47.         TransferErrorToResult(validationResults!, err);
  48.     }
  50.     if (!isValid && breakOnFirstError) return isValid;
  52.     var propertyObjectsAreValid = TryValidatePropertyObjects(
  53.         instance,
  54.         validationContext,
  55.         validationResults,
  56.         asyncValidationBehavior,
  57.         validateAllProperties,
  58.         predicate,
  59.         throwOnFirstError);
  61.     if (isValid && !propertyObjectsAreValid) isValid = false;
  63.     return isValid;
  64. }
复制代码
这个方法是一切递归的开始，因此对象的访问记录也应该从这里开始，只是当时被 Blazor 的代码干扰了一下，老想着在别到处理惩罚这个问题被坑了半个月。参数里的委托是一个自定义判定条件，用于决定是否要验证这个类型的对象，如果你很清楚某个类型内部不会再有验证特性，可以在这里阻止无用的递归。笔者已经在内部排除了大部门已知的无需深入验证的内置类型，例如int、List之类的基本类型和内部不会再有其他直接或间接存在验证特性标记的属性的复杂类型。这里的List中不会继续深入验证是指这个类型本身的属性，例如Count，如果T类型是可能有验证标记的类型是会正常验证的，如果直接继承List再添加自己的新属性也可以正常验证。
对象图的验证结果可能来自深层对象，因此必要一种方法来保留这种结构信息以提供更有价值的验证结果。此处笔者参考Blazor的验证器做了一个更符合这里的需求的版本。如果要重写值类型的相等性判定，则必要谨慎，否则可能出现问题。
  1. public sealed class FieldIdentifier : IEquatable<FieldIdentifier>
  2. {
  3.     private static readonly object TopLevelObjectFaker = new();
  5.     public static FieldIdentifier GetFakeTopLevelObjectIdentifier(string fieldName)
  6.     {
  7.         return new(TopLevelObjectFaker, fieldName, null);
  8.     }
  10.     public FieldIdentifier(object model, string fieldName, FieldIdentifier? modelOwner)
  11.     {
  12.         Model = model ?? throw new ArgumentNullException(nameof(model));
  14.         CheckTopLevelObjectFaker(model, modelOwner);
  16.         // Note that we do allow an empty string. This is used by some validation systems
  17.         // as a place to store object-level (not per-property) messages.
  18.         FieldName = fieldName ?? throw new ArgumentNullException(nameof(fieldName));
  20.         ModelOwner = modelOwner;
  21.     }
  23.     public FieldIdentifier(object model, int enumerableElementIndex, FieldIdentifier? modelOwner)
  24.     {
  25.         Model = model ?? throw new ArgumentNullException(nameof(model));
  27.         CheckTopLevelObjectFaker(model, modelOwner);
  29.         if (enumerableElementIndex < 0)
  30.         {
  31.             throw new ArgumentOutOfRangeException(nameof(enumerableElementIndex), "The index must be great than or equals 0.");
  32.         }
  34.         EnumerableElementIndex = enumerableElementIndex;
  36.         ModelOwner = modelOwner;
  37.     }
  39.     private static void CheckTopLevelObjectFaker(object model, FieldIdentifier? modelOwner)
  40.     {
  41.         if (model == TopLevelObjectFaker && modelOwner is not null)
  42.         {
  43.             throw new ArgumentException($"{nameof(modelOwner)} must be null when {nameof(model)} is {nameof(TopLevelObjectFaker)}", nameof(modelOwner));
  44.         }
  45.     }
  47.     public object Model { get; }
  49.     public bool ModelIsCopiedInstanceOfValueType => Model.GetType().IsValueType;
  51.     public bool ModelIsTopLevelFakeObject => Model == TopLevelObjectFaker;
  53.     public string? FieldName { get; }
  55.     public int? EnumerableElementIndex { get; }
  57.     public FieldIdentifier? ModelOwner { get; }
  59.     /// <inheritdoc />
  60.     public override int GetHashCode()
  61.     {
  62.         // We want to compare Model instances by reference. RuntimeHelpers.GetHashCode returns identical hashes for equal object references (ignoring any `Equals`/`GetHashCode` overrides) which is what we want.
  63.         var modelHash = RuntimeHelpers.GetHashCode(Model);
  64.         var fieldHash = FieldName is null ? 0 : StringComparer.Ordinal.GetHashCode(FieldName);
  65.         var indexHash = EnumerableElementIndex ?? 0;
  66.         var ownerHash = RuntimeHelpers.GetHashCode(ModelOwner);
  67.         return (modelHash, fieldHash, indexHash, ownerHash).GetHashCode();
  68.     }
  70.     /// <inheritdoc />
  71.     public override bool Equals(object? obj)
  72.         => obj is FieldIdentifier otherIdentifier
  73.         && Equals(otherIdentifier);
  75.     /// <inheritdoc />
  76.     public bool Equals(FieldIdentifier? otherIdentifier)
  77.     {
  78.         return (ReferenceEquals(otherIdentifier?.Model, Model) || Equals(otherIdentifier?.Model, Model))
  79.             && string.Equals(otherIdentifier?.FieldName, FieldName, StringComparison.Ordinal)
  80.             && Nullable.Equals(otherIdentifier?.EnumerableElementIndex, EnumerableElementIndex)
  81.             && ReferenceEquals(otherIdentifier?.ModelOwner, ModelOwner);
  82.     }
  84.     /// <inheritdoc/>
  85.     public static bool operator ==(FieldIdentifier? left, FieldIdentifier? right)
  86.     {
  87.         if (left is not null) return left.Equals(right);
  88.         if (right is not null) return right.Equals(left);
  89.         return Equals(left, right);
  90.     }
  92.     /// <inheritdoc/>
  93.     public static bool operator !=(FieldIdentifier? left, FieldIdentifier? right) => !(left == right);
  95.     /// <inheritdoc/>
  96.     public override string? ToString()
  97.     {
  98.         if (ModelIsTopLevelFakeObject) return FieldName;
  100.         var sb = new StringBuilder();
  101.         var fieldIdentifier = this;
  102.         var chainHasTopLevelFaker = false;
  103.         do
  104.         {
  105.             sb.Insert(0, fieldIdentifier.FieldName is not null ? $".{fieldIdentifier.FieldName}" : $"[{fieldIdentifier.EnumerableElementIndex}]");
  107.             if (chainHasTopLevelFaker is false && fieldIdentifier.ModelIsTopLevelFakeObject) chainHasTopLevelFaker = true;
  109.             fieldIdentifier = fieldIdentifier.ModelOwner;
  111.         } while (fieldIdentifier != null && !fieldIdentifier.ModelIsTopLevelFakeObject);
  113.         if (fieldIdentifier is null && !chainHasTopLevelFaker) sb.Insert(0, "$");
  114.         else if (fieldIdentifier is { ModelIsTopLevelFakeObject: true }) sb.Insert(0, fieldIdentifier.FieldName);
  116.         return sb.ToString();
  117.     }
  118. }
复制代码
这里有一个专门用来表示函数参数名或者当地变量名的特殊对象，这个特殊对象只能是根对象，如果没有这个特殊对象做根，根对象会用$符号表示。对于值类型的对象，可以通过属性知道这里保存的对象是复制版，修改这里保存的对象可能无法反馈到原始数据。Blazor则是简单粗暴地在发现传入对象是结构体时直接抛出异常。
最小API自动验证

对于.NET6.0 来说，自己在API端点用对象图验证器验证一下就可以了，也只能这么做。但是 .NET7.0 为最小API也添加了过滤器功能，这使得模拟MVC的自动验证机制成为可能。原来这篇文章应该在将近半个月前发布的，就是因为偶然瞥见 .NET7.0 增加了最小API过滤器，笔者暂时决定一不做二不休，把自动验证的管道过滤器也一并做完再发。
MinimalApis.Extensions是官方文档引用的过滤器应用示例，因此也是下载量比较大的扩展库，别的也有一个基于FluentValidation的。但是笔者的验证功能已经完全自己实现，想要接入进去也不可能了，而且这些库都没有还原出MVC的利用体验。既然如此，干脆完全重写一个更接近MVC体验的算了。
在此，笔者规划实现以下MVC功能：
可能是这个野心太大，原来以为两三天能搞定的，结果在被无尽的bug折磨中将近半个月就过去了。好在这些时间没有白花，预定目标全部实现。
类似MVC，这个验证过滤器也是基于模子元数据的，但是是笔者自己写的独立版本。因为MVC的元数据体系太复杂，而且最小API原来就是为不想用MVC这种复杂框架的人准备的精简版功能，现在回过去依靠MVC的功能也不好。这个元数据体系的核心是保存绑定参数的名字，附加的验证特性和当地化特性等信息。
端点参数验证元数据
  1. internal sealed class EndpointBindingParametersValidationMetadata : IReadOnlyDictionary<string, ParameterValidationMetadata>
  2. {
  3.     private readonly MethodInfo _endpointMethod;
  4.     private readonly IReadOnlyDictionary<string, ParameterValidationMetadata> _metadatas;
  6.     public MethodInfo EndpointMethod => _endpointMethod;
  8.     public EndpointBindingParametersValidationMetadata(MethodInfo endpointMethod, params IEnumerable<ParameterValidationMetadata> metadatas)
  9.     {
  10.         ArgumentNullException.ThrowIfNull(endpointMethod);
  12.         Dictionary<string, ParameterValidationMetadata> tempMetadatas = [];
  13.         HashSet<string> names = [];
  14.         foreach (var metadata in metadatas)
  15.         {
  16.             if (!names.Add(metadata.ParameterName)) throw new ArgumentException("metadata's parameter name must be unique.", nameof(metadatas));
  18.             tempMetadatas.Add(metadata.ParameterName, metadata);
  19.         }
  21.         _metadatas = tempMetadatas.AsReadOnly();
  22.         _endpointMethod = endpointMethod;
  23.     }
  25.     public async ValueTask<Dictionary<string, ValidationResultStore>?> ValidateAsync(IDictionary<string, object?> arguments, CancellationToken cancellationToken = default)
  26.     {
  27.         Dictionary<string, ValidationResultStore> result = [];
  28.         foreach (var argument in arguments)
  29.         {
  30.             if (!_metadatas.TryGetValue(argument.Key, out var metadata))
  31.             {
  32.                 throw new InvalidOperationException($"Parameter named {argument.Key} does not exist.");
  33.             }
  35.             var argumentResults = await metadata.ValidateAsync(argument.Value, cancellationToken);
  36.             if (argumentResults is not null) result.TryAdd(metadata.ParameterName, argumentResults);
  37.         }
  38.         return result.Count > 0 ? result : null;
  39.     }
  41.     public IEnumerable<string> Keys => _metadatas.Keys;
  43.     public IEnumerable<ParameterValidationMetadata> Values => _metadatas.Values;
  45.     public int Count => _metadatas.Count;
  47.     public ParameterValidationMetadata this[string key] => _metadatas[key];
  49.     public bool ContainsKey(string key) => _metadatas.ContainsKey(key);
  51.     public bool TryGetValue(
  52.         string key,
  53.         [MaybeNullWhen(false)] out ParameterValidationMetadata value)
  54.         => _metadatas.TryGetValue(key, out value);
  56.     public IEnumerator<KeyValuePair<string, ParameterValidationMetadata>> GetEnumerator() => _metadatas.GetEnumerator();
  58.     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
  60.     internal sealed class ParameterValidationMetadata
  61.     {
  62.         private ParameterInfo _parameterInfo;
  63.         private string? _displayName;
  64.         private RequiredAttribute? _requiredAttribute;
  65.         private ImmutableList<ValidationAttribute> _otherValidationAttributes;
  67.         public ParameterValidationMetadata(ParameterInfo parameterInfo)
  68.         {
  69.             _parameterInfo = parameterInfo ?? throw new ArgumentNullException(nameof(parameterInfo));
  71.             if (string.IsNullOrEmpty(parameterInfo.Name)) throw new ArgumentException("Parameter must be have name.", nameof(parameterInfo));
  73.             _displayName = parameterInfo.GetCustomAttribute<DisplayAttribute>()?.Name
  74.                 ?? parameterInfo.GetCustomAttribute<DisplayNameAttribute>()?.DisplayName;
  76.             _requiredAttribute = parameterInfo.GetCustomAttribute<RequiredAttribute>();
  77.             _otherValidationAttributes = parameterInfo
  78.                 .GetCustomAttributes<ValidationAttribute>()
  79.                 .Where(attr => attr is not RequiredAttribute)
  80.                 .ToImmutableList();
  81.         }
  83.         public string ParameterName => _parameterInfo.Name!;
  85.         public string? DisplayName => _displayName;
  87.         public ParameterInfo Parameter => _parameterInfo;
  89.         public async ValueTask<ValidationResultStore?> ValidateAsync(object? argument, CancellationToken cancellationToken = default)
  90.         {
  91.             if (argument is not null && !argument.GetType().IsAssignableTo(_parameterInfo.ParameterType))
  92.             {
  93.                 throw new InvalidCastException($"Object cannot assign to {ParameterName} of type {_parameterInfo.ParameterType}.");
  94.             }
  96.             var topName = ParameterName ?? $"<argumentSelf({argument?.GetType()?.Name})>";
  97.             ValidationResultStore resultStore = new();
  98.             List<ValidationResult> results = [];
  100.             var validationContext = new ValidationContext(argument ?? new())
  101.             {
  102.                 MemberName = ParameterName
  103.             };
  105.             if (DisplayName is not null) validationContext.DisplayName = DisplayName;
  107.             // 验证位于参数上的特性
  108.             if (argument is null && _requiredAttribute is not null)
  109.             {
  110.                 var result = _requiredAttribute.GetValidationResult(argument, validationContext)!;
  111.                 result = new LocalizableValidationResult(result.ErrorMessage, result.MemberNames, _requiredAttribute, validationContext);
  112.                 results.Add(result);
  113.             }
  115.             if (argument is not null)
  116.             {
  117.                 foreach (var validation in _otherValidationAttributes)
  118.                 {
  119.                     if (validation is AsyncValidationAttribute asyncValidation)
  120.                     {
  121.                         var result = await asyncValidation.GetValidationResultAsync(argument, validationContext, cancellationToken);
  122.                         if (result != ValidationResult.Success)
  123.                         {
  124.                             result = new LocalizableValidationResult(result!.ErrorMessage, result.MemberNames, validation, validationContext);
  125.                             results.Add(result);
  126.                         }
  127.                     }
  128.                     else
  129.                     {
  130.                         var result = validation.GetValidationResult(argument, validationContext);
  131.                         if (result != ValidationResult.Success)
  132.                         {
  133.                             result = new LocalizableValidationResult(result!.ErrorMessage, result.MemberNames, validation, validationContext);
  134.                             results.Add(result);
  135.                         }
  136.                     }
  137.                 }
  139.                 // 验证对象内部的特性
  140.                 await ObjectGraphValidator.TryValidateObjectAsync(
  141.                     argument,
  142.                     new ValidationContext(argument),
  143.                     resultStore,
  144.                     true,
  145.                     static type => !IsRequestDelegateFactorySpecialBoundType(type),
  146.                     topName,
  147.                     cancellationToken);
  148.             }
  150.             if (results.Count > 0)
  151.             {
  152.                 var id = FieldIdentifier.GetFakeTopLevelObjectIdentifier(topName);
  153.                 resultStore.Add(id, results);
  154.             }
  156.             return resultStore.Any() ? resultStore : null;
  157.         }
  158.     }
  159. }
  161. internal static bool IsRequestDelegateFactorySpecialBoundType(Type type) =>
  162.     type.IsAssignableTo(typeof(HttpContext))
  163.     || type.IsAssignableTo(typeof(HttpRequest))
  164.     || type.IsAssignableTo(typeof(HttpResponse))
  165.     || type.IsAssignableTo(typeof(ClaimsPrincipal))
  166.     || type.IsAssignableTo(typeof(CancellationToken))
  167.     || type.IsAssignableTo(typeof(IFormFile))
  168.     || type.IsAssignableTo(typeof(IEnumerable<IFormFile>))
  169.     || type.IsAssignableTo(typeof(Stream))
  170.     || type.IsAssignableTo(typeof(PipeReader));
复制代码
端点过滤器工厂

必要在端点构建阶段利用端点信息生成参数验证元数据并保存到端点元数据备用，再通过元数据生成结果决定是否必要添加验证过滤器，端点过滤器工厂刚好能实现这个目的。
  1. public static EndpointParameterDataAnnotationsRouteHandlerBuilder<TBuilder> AddEndpointParameterDataAnnotations<TBuilder>(
  2.     this TBuilder endpointConvention)
  3.     where TBuilder : IEndpointConventionBuilder
  4. {
  5.     endpointConvention.Add(static endpointBuilder =>
  6.     {
  7.         var loggerFactory = endpointBuilder.ApplicationServices.GetRequiredService<ILoggerFactory>();
  8.         var logger = loggerFactory.CreateLogger(_filterLoggerName);
  10.         // 排除MVC端点
  11.         if (endpointBuilder.Metadata.Any(static md => md is ActionDescriptor))
  12.         {
  13.             logger.LogDebug("Cannot add parameter data annotations validation filter to MVC controller or Razor pages endpoint {actionName}.", endpointBuilder.DisplayName);
  14.             return;
  15.         }
  17.         // 检查重复注册自动验证过滤器
  18.         if (endpointBuilder.Metadata.Any(static md => md is EndpointBindingParametersValidationMetadata))
  19.         {
  20.             logger.LogDebug("Already has a parameter data annotations validation filter on endpoint {actionName}.", endpointBuilder.DisplayName);
  21.             return;
  22.         }
  24.         if (endpointBuilder.Metadata.Any(static md => md is EndpointBindingParametersValidationMetadataMark))
  25.         {
  26.             logger.LogDebug("Already called method AddEndpointParameterDataAnnotations before on endpoint {actionName}.", endpointBuilder.DisplayName);
  27.             return;
  28.         }
  30.         // 标记自动验证过滤器已经注册
  31.         endpointBuilder.Metadata.Add(new EndpointBindingParametersValidationMetadataMark());
  33.         endpointBuilder.FilterFactories.Add((filterFactoryContext, next) =>
  34.         {
  35.             var loggerFactory = filterFactoryContext.ApplicationServices.GetRequiredService<ILoggerFactory>();
  36.             var logger = loggerFactory.CreateLogger(_filterLoggerName);
  38.             var parameters = filterFactoryContext.MethodInfo.GetParameters();
  40.             // 查找绑定参数，记录索引备用
  41.             var isServicePredicate = filterFactoryContext.ApplicationServices.GetService<IServiceProviderIsService>();
  42.             List<int> bindingParameterIndexs = new(parameters.Length);
  43.             for (int i = 0; i < parameters.Length; i++)
  44.             {
  45.                 ParameterInfo? parameter = parameters[i];
  46.                 if (IsRequestDelegateFactorySpecialBoundType(parameter.ParameterType)) continue;
  47.                 if (parameter.GetCustomAttribute<FromServicesAttribute>() is not null) continue;
  48. #if NET8_0_OR_GREATER
  49.                 if (parameter.GetCustomAttribute<FromKeyedServicesAttribute>() is not null) continue;
  50. #endif
  51.                 if (isServicePredicate?.IsService(parameter.ParameterType) is true) continue;
  53.                 bindingParameterIndexs.Add(i);
  54.             }
  56.             if (bindingParameterIndexs.Count is 0)
  57.             {
  58.                 logger.LogDebug("Route handler method '{methodName}' does not contain any validatable parameters, skipping adding validation filter.", filterFactoryContext.MethodInfo.Name);
  59.             }
  61.             // 构建参数模型验证元数据添加到端点元数据集合
  62.             EndpointBindingParametersValidationMetadata? validationMetadata;
  63.             try
  64.             {
  65.                 List<ParameterValidationMetadata> bindingParameters = new(bindingParameterIndexs.Count);
  66.                 foreach (var argumentIndex in bindingParameterIndexs)
  67.                 {
  68.                     bindingParameters.Add(new(parameters[argumentIndex]));
  69.                 }
  70.                 validationMetadata = new(filterFactoryContext.MethodInfo, bindingParameters);
  71.             }
  72.             catch (Exception e)
  73.             {
  74.                 validationMetadata = null;
  75.                 logger.LogError(e, "Build parameter validation metadate failed for route handler method '{methodName}', skipping adding validation filter.", filterFactoryContext.MethodInfo.Name);
  76.             }
  78.             if (validationMetadata?.Any() is not true) return invocationContext => next(invocationContext);
  80.             endpointBuilder.Metadata.Add(validationMetadata);
  82.             // 一切顺利，注册验证过滤器
  83.             return async invocationContext =>
  84.             {
  85.                 var endpoint = invocationContext.HttpContext.GetEndpoint();
  86.                 var metadata = endpoint?.Metadata
  87.                     .FirstOrDefault(static md => md is EndpointBindingParametersValidationMetadata) as EndpointBindingParametersValidationMetadata;
  89.                 if (metadata is null) return await next(invocationContext);
  91.                 Dictionary<string, object?> arguments = new(bindingParameterIndexs.Count);
  92.                 foreach (var argumentIndex in bindingParameterIndexs)
  93.                 {
  94.                     arguments.Add(parameters[argumentIndex].Name!, invocationContext.Arguments[argumentIndex]);
  95.                 }
  97.                 try
  98.                 {
  99.                     var results = await metadata.ValidateAsync(arguments);
  100.                     if (results != null) invocationContext.HttpContext.Items.Add(_validationResultItemName, results);
  101.                 }
  102.                 catch (Exception e)
  103.                 {
  104.                     logger.LogError(e, "Validate parameter failed for route handler method '{methodName}'.", filterFactoryContext.MethodInfo.Name);
  105.                 }
  107.                 return await next(invocationContext);
  108.             };
  109.         });
  110.     });
  112.     return new(endpointConvention);
  113. }
  115. public sealed class EndpointBindingParametersValidationMetadataMark;
复制代码
这里返回特殊类型的构造器并用作错误结果过滤器的参数，确保错误结果过滤器只能在参数验证过滤器之后注册。
自动验证错误返回过滤器
  1. public static TBuilder AddValidationProblemResult<TBuilder>(
  2.     this EndpointParameterDataAnnotationsRouteHandlerBuilder<TBuilder> validationEndpointBuilder,
  3.     int statusCode = StatusCodes.Status400BadRequest)
  4.     where TBuilder : IEndpointConventionBuilder
  5. {
  6.     validationEndpointBuilder.InnerBuilder.Add(endpointBuilder =>
  7.     {
  8.         var loggerFactory = endpointBuilder.ApplicationServices.GetRequiredService<ILoggerFactory>();
  9.         var logger = loggerFactory.CreateLogger(_filterLoggerName);
  11.         // 检查 OpenAPI 元数据是否存在
  12.         if (!endpointBuilder.Metadata.Any(static md =>
  13.             md is IProducesResponseTypeMetadata pr
  14.             && (pr.Type?.IsAssignableTo(typeof(HttpValidationProblemDetails))) is true)
  15.         )
  16.         {
  17.             // 添加 OpenAPI 元数据
  18.             endpointBuilder.Metadata.Add(
  19.                 new ProducesResponseTypeMetadata(
  20.                     statusCode,
  21.                     typeof(HttpValidationProblemDetails),
  22.                     ["application/problem+json", "application/json"]
  23.                 )
  24.             );
  25.         }
  27.         // 检查重复注册自动验证错误返回过滤器
  28.         if (endpointBuilder.Metadata.Any(static md => md is EndpointParameterDataAnnotationsValidationProblemResultMark))
  29.         {
  30.             logger.LogDebug("Already has a parameter data annotations validation problem result filter on endpoint {actionName}.", endpointBuilder.DisplayName);
  31.             return;
  32.         }
  34.         // 标记自动验证错误返回过滤器已经注册
  35.         endpointBuilder.Metadata.Add(new EndpointParameterDataAnnotationsValidationProblemResultMark());
  37.         endpointBuilder.FilterFactories.Add(static (filterFactoryContext, next) =>
  38.         {
  39.             return async invocationContext =>
  40.             {
  41.                 var errors = invocationContext.HttpContext.GetEndpointParameterDataAnnotationsProblemDetails();
  43.                 if (errors is { Count: > 0 }) return Results.ValidationProblem(errors);
  44.                 else return await next(invocationContext);
  45.             };
  46.         });
  47.     });
  49.     return validationEndpointBuilder.InnerBuilder;
  50. }
  52. public static TBuilder RestoreToOriginalBuilder<TBuilder>(this EndpointParameterDataAnnotationsRouteHandlerBuilder<TBuilder> validationEndpointBuilder)
  53.     where TBuilder : IEndpointConventionBuilder
  54. {
  55.     return validationEndpointBuilder.InnerBuilder;
  56. }
  58. public sealed class EndpointParameterDataAnnotationsValidationProblemResultMark;
复制代码
注册错误结果过滤器后返回原始构造器，可用于继续注册其他东西。或者用专门的辅助方法直接还原，跳过注册错误结果过滤器。
手动重新验证参数
  1. public static async Task<bool> TryValidateEndpointParametersAsync(
  2.     this HttpContext httpContext,
  3.     params IEnumerable<KeyValuePair<string, object?>> arguments)
  4. {
  5.      ArgumentNullException.ThrowIfNull(httpContext);
  7.     var metadata = httpContext.GetEndpointBindingParameterValidationMetadata();
  8.     if (metadata is null) return false;
  10.     if (!arguments.Any()) throw new ArgumentException("There are no elements in the sequence.", nameof(arguments));
  12.     HashSet<string> names = [];
  13.     foreach (var name in arguments.Select(arg => arg.Key))
  14.     {
  15.         if (string.IsNullOrEmpty(name)) throw new ArgumentException("Argument's name cannot be null or empty.", nameof(arguments));
  16.         if (!names.Add(name)) throw new ArgumentException("Argument's name must be unique.", nameof(arguments));
  17.     }
  19.     var currentResults = httpContext.GetEndpointParameterDataAnnotationsValidationResultsCore();
  20.     var newResults = await metadata.ValidateAsync(arguments.ToDictionary(arg => arg.Key, arg => arg.Value));
  22.     if (newResults is null) // 本次验证结果没有任何错误
  23.     {
  24.         if (currentResults != null)
  25.         {
  26.             // 移除本次验证结果中没有验证错误数据的参数项
  27.             foreach (var argument in arguments) currentResults.Remove(argument.Key);
  28.             // 如果移除后变成空集，直接清除结果集
  29.             if (currentResults.Count is 0) httpContext.Items.Remove(_validationResultItemName);
  30.         }
  31.     }
  32.     else
  33.     {
  34.         if (currentResults != null)
  35.         {
  36.             // 如果上次的验证结果中有同名参数的数据，但本次验证结果中没有，移除该参数的过时的旧结果数据
  37.             foreach (var argument in arguments)
  38.             {
  39.                 if (!newResults.Keys.Any(key => key == argument.Key)) currentResults.Remove(argument.Key);
  40.             }
  41.         }
  42.         else
  43.         {
  44.             // 上次验证结果显示没有任何错误，新建错误结果集
  45.             httpContext.Items.Remove(_validationResultItemName);
  47.             currentResults = [];
  48.             httpContext.Items.Add(_validationResultItemName, currentResults);
  49.         }
  50.         // 添加上次验证中没有错误数据的参数项，或者更新同名参数项的验证错误数据
  51.         foreach (var newResult in newResults) currentResults[newResult.Key] = newResult.Value;
  52.     }
  54.     return true;
  55. }
复制代码
可以说构建元数据的根本目的就是为了支持手动重新验证，MVC的手动重新验证同样也是依靠元数据体系。确实是个好想法，鉴戒过来用。
获取验证结果
  1. internal static Dictionary<string, ValidationResultStore>? GetEndpointParameterDataAnnotationsValidationResultsCore(this HttpContext httpContext)
  2. {
  3.     ArgumentNullException.ThrowIfNull(httpContext);
  5.     httpContext.Items.TryGetValue(_validationResultItemName, out var result);
  6.     return result as Dictionary<string, ValidationResultStore>;
  7. }
  9. public static EndpointArgumentsValidationResults? GetEndpointParameterDataAnnotationsValidationResults(this HttpContext httpContext)
  10. {
  11.     var results = httpContext.GetEndpointParameterDataAnnotationsValidationResultsCore();
  12.     if (results is null) return null;
  14.     return new(results
  15.         .ToDictionary(
  16.             static r => r.Key,
  17.             static r => new ArgumentPropertiesValidationResults(r.Value.ToDictionary(
  18.                 static fr => fr.Key.ToString()!,
  19.                 static fr => fr.Value.ToImmutableList())
  20.             )
  21.         )
  22.     );
  23. }
复制代码
获取当地化的验证错误消息

我们知道MVC的当地化功能非常灵活，支持消息模板，能在最大程度上使当地化资源通用。但是不同的验证特性的消息模板占位符不尽雷同，除了0号占位符统一表示属性名以外，其他占位符的数量是不确定的。因此MVC框架利用了一套适配器来允许开辟者自行开有发针对性的消息生成,同时为内置验证特性准备了一组适配器。笔者也鉴戒这套适配器体系开辟了一个简易版，并内置了官方现有验证特性的适配器。重要区别是这套适配器没有客户端验证相关的功能。
  1. public interface IAttributeAdapter
  2. {
  3.     Type CanProcessAttributeType { get; }
  5.     object[]? GetLocalizationArguments(ValidationAttribute attribute);
  6. }
  8. public abstract class AttributeAdapterBase<TAttribute> : IAttributeAdapter
  9.     where TAttribute : ValidationAttribute
  10. {
  11.     public Type CanProcessAttributeType => typeof(TAttribute);
  13.     public object[]? GetLocalizationArguments(ValidationAttribute attribute)
  14.     {
  15.         return GetLocalizationArgumentsInternal((TAttribute)attribute);
  16.     }
  18.     protected abstract object[]? GetLocalizationArgumentsInternal(TAttribute attribute);
  19. }
  21. public sealed class RangeAttributeAdapter : AttributeAdapterBase<RangeAttribute>
  22. {
  23.     protected override object[]? GetLocalizationArgumentsInternal(RangeAttribute attribute)
  24.     {
  25.         return [attribute.Minimum, attribute.Maximum];
  26.     }
  27. }
复制代码
有了消息模板占位符参数后，剩下的就好办了。
  1. public static Dictionary<string, string[]>? GetEndpointParameterDataAnnotationsProblemDetails(this HttpContext httpContext)
  2. {
  3.     Dictionary<string, string[]>? result = null;
  5.     var validationResult = httpContext.GetEndpointParameterDataAnnotationsValidationResultsCore();
  6.     if (validationResult?.Any(vrp => vrp.Value.Any()) is true)
  7.     {
  8.         var localizerFactory = httpContext.RequestServices.GetService<IStringLocalizerFactory>();
  10.         EndpointParameterValidationLocalizationOptions? localizationOptions = null;
  11.         AttributeLocalizationAdapters? adapters = null;
  12.         if (localizerFactory != null)
  13.         {
  14.             localizationOptions = httpContext.RequestServices
  15.                 .GetService<IOptions<EndpointParameterValidationLocalizationOptions>>()
  16.                 ?.Value;
  18.             adapters = localizationOptions?.Adapters;
  19.         }
  21.         var metadatas = httpContext.GetEndpointBindingParameterValidationMetadata();
  22.         Debug.Assert(metadatas != null);
  23.         var endpointHandlerType = metadatas.EndpointMethod.ReflectedType;
  24.         Debug.Assert(endpointHandlerType != null);
  26.         var errors = validationResult.SelectMany(vrp => vrp.Value);
  27.         result = localizerFactory is null || !(adapters?.Count > 0)
  28.             ? errors
  29.                 .ToDictionary(
  30.                     static fvr => fvr.Key.ToString()!,
  31.                     static fvr => fvr.Value.Select(ToErrorMessage).ToArray()
  32.                 )
  33.             : errors
  34.                 .ToDictionary(
  35.                     static fvr => fvr.Key.ToString()!,
  36.                     fvr => fvr.Value
  37.                         .Select(vr =>
  38.                             ToLocalizedErrorMessage(
  39.                                 vr,
  40.                                 fvr.Key.ModelIsTopLevelFakeObject
  41.                                     ? new KeyValuePair<Type, ParameterValidationMetadata>(
  42.                                         endpointHandlerType,
  43.                                         (metadatas?.TryGetValue(fvr.Key.FieldName!, out var metadata)) is true
  44.                                             ? metadata
  45.                                             : null! /* never null */)
  46.                                     : null,
  47.                                 adapters,
  48.                                 localizerFactory
  49.                             )
  50.                         )
  51.                         .ToArray()
  52.                 );
  53.     }
  55.     return result;
  57.     static string ToErrorMessage(ValidationResult result)
  58.     {
  59.         return result.ErrorMessage!;
  60.     }
  62.     string ToLocalizedErrorMessage(
  63.         ValidationResult result,
  64.         KeyValuePair<Type, ParameterValidationMetadata>? parameterMetadata,
  65.         AttributeLocalizationAdapters adapters,
  66.         IStringLocalizerFactory localizerFactory)
  67.     {
  68.         if (result is LocalizableValidationResult localizable)
  69.         {
  70.             var localizer = localizerFactory.Create(localizable.InstanceObjectType);
  72.             string displayName;
  73.             if (!string.IsNullOrEmpty(parameterMetadata?.Value.DisplayName))
  74.             {
  75.                 var parameterLocalizer = localizerFactory.Create(parameterMetadata.Value.Key);
  76.                 displayName = parameterLocalizer[parameterMetadata.Value.Value.DisplayName];
  77.             }
  78.             else displayName = GetDisplayName(localizable, localizer);
  80.             var adapter = adapters.FirstOrDefault(ap => localizable.Attribute.GetType().IsAssignableTo(ap.CanProcessAttributeType));
  81.             if (adapter != null
  82.                 && !string.IsNullOrEmpty(localizable.Attribute.ErrorMessage)
  83.                 && string.IsNullOrEmpty(localizable.Attribute.ErrorMessageResourceName)
  84.                 && localizable.Attribute.ErrorMessageResourceType == null)
  85.             {
  86.                 return localizer
  87.                 [
  88.                     localizable.Attribute.ErrorMessage,
  89.                     [displayName, .. adapter.GetLocalizationArguments(localizable.Attribute) ?? []]
  90.                 ];
  91.             }
  93.             return localizable.Attribute.FormatErrorMessage(displayName);
  94.         }
  96.         return result.ErrorMessage!;
  98.         static string GetDisplayName(LocalizableValidationResult localizable, IStringLocalizer localizer)
  99.         {
  100.             string? displayName = null;
  101.             ValidationAttributeStore store = ValidationAttributeStore.Instance;
  102.             DisplayAttribute? displayAttribute = null;
  103.             DisplayNameAttribute? displayNameAttribute = null;
  105.             if (string.IsNullOrEmpty(localizable.MemberName))
  106.             {
  107.                 displayAttribute = store.GetTypeDisplayAttribute(localizable.Context);
  108.                 displayNameAttribute = store.GetTypeDisplayNameAttribute(localizable.Context);
  109.             }
  110.             else if (store.IsPropertyContext(localizable.Context))
  111.             {
  112.                 displayAttribute = store.GetPropertyDisplayAttribute(localizable.Context);
  113.                 displayNameAttribute = store.GetPropertyDisplayNameAttribute(localizable.Context);
  114.             }
  116.             if (displayAttribute != null)
  117.             {
  118.                 displayName = displayAttribute.GetName();
  119.             }
  120.             else if (displayNameAttribute != null)
  121.             {
  122.                 displayName = displayNameAttribute.DisplayName;
  123.             }
  125.             return string.IsNullOrEmpty(displayName)
  126.                 ? localizable.DisplayName
  127.                 : localizer[displayName];
  128.         }
  129.     }
  130. }
复制代码
当地化错误消息可以说是整个工程里最贫苦的部门，为此乃至改造了一番对象图验证器。因为MVC根本没有利用验证器，而是直接利用原始验证特性，这意味着MVC可以得到最原始的信息举行任何自定义处理惩罚。为了做到同样的效果，必须让对象图验证器也返回包罗原始信息的验证结果。其中的关键就是LocalizableValidationResult，这个新类型保存了当地化所需的一切原始信息。对象图验证器会在得到验证结果后将原始结果重新包装一次，因此这些信息在非MVC环境下同样可用。
另有就是针对参数本身的特殊处理惩罚，参数名和参数上的特性和对象内部的特性无法通用一套逻辑，必须分别处理惩罚。为此又把事情给弄贫苦了一些，也算是再次感受到MVC的元数据体系的强盛。
基本利用方法

Nuget包中有一个比较完备的示例说明，也比较长，就不赘述了，可以到这里查看利用说明。
结语

这真是一次漫长的开辟之旅，一开始就对开辟难度估计不足，把自己坑进去一个多星期，然后半路暂时追加新功能，又被坑进去一个多星期。还好前期开辟的功能比较严谨，为暂时功能做改造还算顺利。也算是好好体会了一把严谨设计的威力，跟着微软的代码照猫画虎是真的能提前避开很多坑啊。
QQ群

读者交换QQ群：540719365

欢迎读者和广大朋侪一起交换，如发现本书错误也欢迎通过博客园、QQ群等方式告知笔者。
本文地址：如何优雅地让 ASP.NET Core 支持异步模子验证

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 qidao123.com技术社区-IT企服评测·应用市场 (https://dis.qidao123.com/) Powered by Discuz! X3.4