Add built-in support for async form validation in Blazor

src/Components/Forms/src/EditContextDataAnnotationsExtensions.cs

@@ -68,6 +68,7 @@ public DataAnnotationsEventSubscriptions(EditContext editContext, IServiceProvid
 #pragma warning restore ASP0029 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
             _editContext.OnFieldChanged += OnFieldChanged;
             _editContext.OnValidationRequested += OnValidationRequested;
+            _editContext.OnValidationRequestedAsync += OnValidationRequestedAsync;
 
             if (MetadataUpdater.IsSupported)
             {
@@ -79,44 +80,53 @@ public DataAnnotationsEventSubscriptions(EditContext editContext, IServiceProvid
         private void OnFieldChanged(object? sender, FieldChangedEventArgs eventArgs)
         {
             var fieldIdentifier = eventArgs.FieldIdentifier;
-            if (TryGetValidatableProperty(fieldIdentifier, out var propertyInfo))
-            {
-                var propertyValue = propertyInfo.GetValue(fieldIdentifier.Model);
-                var validationContext = new ValidationContext(fieldIdentifier.Model, _serviceProvider, items: null)
-                {
-                    MemberName = propertyInfo.Name
-                };
-                var results = new List<ValidationResult>();
-
-                Validator.TryValidateProperty(propertyValue, validationContext, results);
-                _messages.Clear(fieldIdentifier);
-                foreach (var result in CollectionsMarshal.AsSpan(results))
-                {
-                    _messages.Add(fieldIdentifier, result.ErrorMessage!);
-                }
 
-                // We have to notify even if there were no messages before and are still no messages now,
-                // because the "state" that changed might be the completion of some async validation task
-                _editContext.NotifyValidationStateChanged();
+#pragma warning disable ASP0029 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
+            if (_validatorTypeInfo is ValidatableTypeInfo typeInfo &&
+                typeInfo.GetProperty(fieldIdentifier.FieldName) is ValidatablePropertyInfo validatablePropertyInfo)
+            {
+                var cts = new CancellationTokenSource();
+                var task = ValidateFieldAsync(fieldIdentifier, validatablePropertyInfo, cts.Token);
+                _editContext.AddValidationTask(fieldIdentifier, task, cts);
+            }
+#pragma warning restore ASP0029 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
+            else if (TryGetValidatableProperty(fieldIdentifier, out var propertyInfo))
+            {
+                ValidateField(fieldIdentifier, propertyInfo);
             }
         }
 
-        [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Model types are expected to be defined in assemblies that do not get trimmed.")]
         private void OnValidationRequested(object? sender, ValidationRequestedEventArgs e)
         {
-            var validationContext = new ValidationContext(_editContext.Model, _serviceProvider, items: null);
+            if (_validatorTypeInfo is not null)
+            {
+                // The IValidatableInfo path runs through OnValidationRequestedAsync.
+                // EditContext.Validate() drains async handlers synchronously and throws if any
+                // are truly async, preserving the behavior where sync IValidatableInfo validators
+                // run during Validate().
+                return;
+            }
+
+            ValidateForm();
+            _editContext.NotifyValidationStateChanged();
+        }
 
-            if (!TryValidateTypeInfo(validationContext))
+        private async Task OnValidationRequestedAsync(object sender, ValidationRequestedEventArgs e)
+        {
+            if (_validatorTypeInfo is null)
             {
-                ValidateWithDefaultValidator(validationContext);
+                // The async path requires IValidatableInfo for the model.
+                return;
             }
 
+            await ValidateFormAsync(_validatorTypeInfo, e.CancellationToken);
             _editContext.NotifyValidationStateChanged();
         }
 
         [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Model types are expected to be defined in assemblies that do not get trimmed.")]
-        private void ValidateWithDefaultValidator(ValidationContext validationContext)
+        private void ValidateForm()
         {
+            var validationContext = new ValidationContext(_editContext.Model, _serviceProvider, items: null);
             var validationResults = new List<ValidationResult>();
             Validator.TryValidateObject(_editContext.Model, validationContext, validationResults, true);
 
@@ -144,34 +154,29 @@ private void ValidateWithDefaultValidator(ValidationContext validationContext)
         }
 
 #pragma warning disable ASP0029 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
-        private bool TryValidateTypeInfo(ValidationContext validationContext)
+        [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Model types are expected to be defined in assemblies that do not get trimmed.")]
+        private async Task ValidateFormAsync(IValidatableInfo validatableInfo, CancellationToken cancellationToken)
         {
-            if (_validatorTypeInfo is null)
-            {
-                return false;
-            }
-
+            var validationContext = new ValidationContext(_editContext.Model, _serviceProvider, items: null);
             var validateContext = new ValidateContext
             {
                 ValidationOptions = _validationOptions!,
                 ValidationContext = validationContext,
             };
+
+            // Clear stale messages up-front. If the validator throws partway through, the form
+            // shows no per-field messages (form-level fault state is signaled separately via
+            // EditContext.IsValidationFaulted). Stale messages from a prior pass would be misleading
+            // because they reflect a different model state.
+            _messages.Clear();
+
             try
             {
                 validateContext.OnValidationError += AddMapping;
 
-                var validationTask = _validatorTypeInfo.ValidateAsync(_editContext.Model, validateContext, CancellationToken.None);
-                if (!validationTask.IsCompleted)
-                {
-                    throw new InvalidOperationException("Async validation is not supported");
-                }
+                await validatableInfo.ValidateAsync(_editContext.Model, validateContext, cancellationToken);
 
-                var validationErrors = validateContext.ValidationErrors;
-
-                // Transfer results to the ValidationMessageStore
-                _messages.Clear();
-
-                if (validationErrors is not null && validationErrors.Count > 0)
+                if (validateContext.ValidationErrors is { Count: > 0 } validationErrors)
                 {
                     foreach (var (fieldKey, messages) in validationErrors)
                     {
@@ -180,19 +185,77 @@ private bool TryValidateTypeInfo(ValidationContext validationContext)
                     }
                 }
             }
-            catch (Exception)
-            {
-                throw;
-            }
             finally
             {
                 validateContext.OnValidationError -= AddMapping;
                 _validationPathToFieldIdentifierMapping.Clear();
             }
+        }
 
-            return true;
+        [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Model types are expected to be defined in assemblies that do not get trimmed.")]
+        private void ValidateField(FieldIdentifier fieldIdentifier, PropertyInfo propertyInfo)
+        {
+            var propertyValue = propertyInfo.GetValue(fieldIdentifier.Model);
+            var validationContext = new ValidationContext(fieldIdentifier.Model, _serviceProvider, items: null)
+            {
+                MemberName = propertyInfo.Name
+            };
+            var results = new List<ValidationResult>();
 
+            Validator.TryValidateProperty(propertyValue, validationContext, results);
+            _messages.Clear(fieldIdentifier);
+            foreach (var result in CollectionsMarshal.AsSpan(results))
+            {
+                _messages.Add(fieldIdentifier, result.ErrorMessage!);
+            }
+
+            // We have to notify even if there were no messages before and are still no messages now,
+            // because the "state" that changed might be the completion of some async validation task
+            _editContext.NotifyValidationStateChanged();
         }
+
+        [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Model types are expected to be defined in assemblies that do not get trimmed.")]
+        private async Task ValidateFieldAsync(
+            FieldIdentifier fieldIdentifier,
+            ValidatablePropertyInfo validatableInfo,
+            CancellationToken cancellationToken)
+        {
+            var validationContext = new ValidationContext(fieldIdentifier.Model, _serviceProvider, items: null);
+            var validateContext = new ValidateContext
+            {
+                ValidationOptions = _validationOptions!,
+                ValidationContext = validationContext,
+            };
+
+            // Clear stale messages up-front so the field shows neutral state during validation
+            // and shows neutral state after a throw or cancellation. Any faulted state is signaled
+            // separately via EditContext.IsValidationFaulted.
+            _messages.Clear(fieldIdentifier);
+            _editContext.NotifyValidationStateChanged();
+
+            try
+            {
+                await validatableInfo.ValidateAsync(fieldIdentifier.Model, validateContext, cancellationToken);
+            }
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+            {
+                // Task was cancelled (user re-edited field or form is submitting). Messages were
+                // already cleared above; just notify so the UI re-renders.
+                _editContext.NotifyValidationStateChanged();
+                return;
+            }
+
+            if (validateContext.ValidationErrors is { Count: > 0 } validationErrors)
+            {
+                foreach (var (_, messages) in validationErrors)
+                {
+                    _messages.Add(fieldIdentifier, messages);
+                }
+            }
+
+            _editContext.NotifyValidationStateChanged();
+        }
+
         private void AddMapping(ValidationErrorContext context)
         {
             _validationPathToFieldIdentifierMapping[context.Path] =
@@ -204,6 +267,7 @@ public void Dispose()
             _messages.Clear();
             _editContext.OnFieldChanged -= OnFieldChanged;
             _editContext.OnValidationRequested -= OnValidationRequested;
+            _editContext.OnValidationRequestedAsync -= OnValidationRequestedAsync;
             _editContext.NotifyValidationStateChanged();
 
             if (MetadataUpdater.IsSupported)

src/Components/Forms/src/FieldState.cs

@@ -20,6 +20,12 @@ public FieldState(FieldIdentifier fieldIdentifier)
 
     public bool IsModified { get; set; }
 
+    // Async validation tracking: the currently-tracked async validation task for this field,
+    // the CancellationTokenSource that can cancel it, and whether the last task faulted.
+    internal Task? PendingValidationTask { get; set; }
+    internal CancellationTokenSource? PendingValidationCts { get; set; }
+    internal bool IsValidationFaulted { get; set; }
+
     public IEnumerable<string> GetValidationMessages()
     {
         if (_validationMessageStores != null)

src/Components/Forms/src/PublicAPI.Unshipped.txt

@@ -1,3 +1,14 @@
 #nullable enable
+Microsoft.AspNetCore.Components.Forms.ValidationRequestedEventArgs.ValidationRequestedEventArgs(System.Threading.CancellationToken cancellationToken) -> void
+Microsoft.AspNetCore.Components.Forms.ValidationRequestedEventArgs.CancellationToken.get -> System.Threading.CancellationToken
 *REMOVED*static Microsoft.AspNetCore.Components.Forms.EditContextDataAnnotationsExtensions.AddDataAnnotationsValidation(this Microsoft.AspNetCore.Components.Forms.EditContext! editContext) -> Microsoft.AspNetCore.Components.Forms.EditContext!
 *REMOVED*static Microsoft.AspNetCore.Components.Forms.EditContextDataAnnotationsExtensions.EnableDataAnnotationsValidation(this Microsoft.AspNetCore.Components.Forms.EditContext! editContext) -> System.IDisposable!
+Microsoft.AspNetCore.Components.Forms.EditContext.OnValidationRequestedAsync -> System.Func<object!, Microsoft.AspNetCore.Components.Forms.ValidationRequestedEventArgs!, System.Threading.Tasks.Task!>?
+Microsoft.AspNetCore.Components.Forms.EditContext.ValidateAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<bool>!
+Microsoft.AspNetCore.Components.Forms.EditContext.AddValidationTask(in Microsoft.AspNetCore.Components.Forms.FieldIdentifier fieldIdentifier, System.Threading.Tasks.Task! task, System.Threading.CancellationTokenSource! cts) -> void
+Microsoft.AspNetCore.Components.Forms.EditContext.IsValidationPending(in Microsoft.AspNetCore.Components.Forms.FieldIdentifier fieldIdentifier) -> bool
+Microsoft.AspNetCore.Components.Forms.EditContext.IsValidationPending<TField>(System.Linq.Expressions.Expression<System.Func<TField>!>! accessor) -> bool
+Microsoft.AspNetCore.Components.Forms.EditContext.IsValidationPending() -> bool
+Microsoft.AspNetCore.Components.Forms.EditContext.IsValidationFaulted(in Microsoft.AspNetCore.Components.Forms.FieldIdentifier fieldIdentifier) -> bool
+Microsoft.AspNetCore.Components.Forms.EditContext.IsValidationFaulted<TField>(System.Linq.Expressions.Expression<System.Func<TField>!>! accessor) -> bool
+Microsoft.AspNetCore.Components.Forms.EditContext.IsValidationFaulted() -> bool

src/Components/Forms/src/ValidationRequestedEventArgs.cs

@@ -19,4 +19,23 @@ public sealed class ValidationRequestedEventArgs : EventArgs
     public ValidationRequestedEventArgs()
     {
     }
+
+    /// <summary>
+    /// Creates a new instance of <see cref="ValidationRequestedEventArgs"/> with the specified
+    /// <see cref="System.Threading.CancellationToken"/>.
+    /// </summary>
+    /// <param name="cancellationToken">A token that signals when the caller has requested
+    /// cancellation of the in-flight async validation pass.</param>
+    public ValidationRequestedEventArgs(CancellationToken cancellationToken)
+    {
+        CancellationToken = cancellationToken;
+    }
+
+    /// <summary>
+    /// Gets a token that signals when the caller has requested cancellation of the in-flight
+    /// async validation pass. Synchronous handlers can ignore this; async handlers that perform
+    /// long-running work (database lookups, remote API calls) should pass it to their downstream
+    /// APIs so the work can be aborted promptly.
+    /// </summary>
+    public CancellationToken CancellationToken { get; }
 }

src/Components/Web/src/Forms/EditForm.cs

@@ -201,7 +201,7 @@ private async Task HandleSubmitAsync()
         else
         {
             // Otherwise, the system implicitly runs validation on form submission
-            var isValid = _editContext.Validate(); // This will likely become ValidateAsync later
+            var isValid = await _editContext.ValidateAsync();
 
             if (isValid && OnValidSubmit.HasDelegate)
             {

src/Validation/src/PublicAPI.Unshipped.txt

@@ -1 +1,2 @@
 #nullable enable
+Microsoft.Extensions.Validation.ValidatableTypeInfo.GetProperty(string! propertyName) -> Microsoft.Extensions.Validation.ValidatablePropertyInfo?

src/Validation/src/ValidatableTypeInfo.cs

@@ -47,6 +47,24 @@ protected ValidatableTypeInfo(
     /// </summary>
     internal IReadOnlyList<ValidatablePropertyInfo> Members { get; }
 
+    /// <summary>
+    /// Finds a validatable property by name.
+    /// </summary>
+    /// <param name="propertyName">The property name to look up.</param>
+    /// <returns>The <see cref="ValidatablePropertyInfo"/> for the property, or <see langword="null"/> if not found.</returns>
+    public ValidatablePropertyInfo? GetProperty(string propertyName)
+    {
+        for (var i = 0; i < _membersCount; i++)
+        {
+            if (string.Equals(Members[i].Name, propertyName, StringComparison.Ordinal))
+            {
+                return Members[i];
+            }
+        }
+
+        return null;
+    }
+
     /// <inheritdoc />
     public virtual async Task ValidateAsync(object? value, ValidateContext context, CancellationToken cancellationToken)
     {