[Blazor] Form mapping error handling and validation integration for SSR Blazor (#48990)

[Blazor] Model binding error handling and validation integration

* Implemented error handling and reporting for form data mapping for Minimal APIs and Blazor.

* Minimal APIs: An exception is throw on the first validation error.
* Blazor: A callback is provided to capture the errors. Binding continues when no exception
is thrown from the callback. 
  * This enables us to capture as much information as possible in
the presence of errors.
  * Errors are represented as FormattableString so that the error message can be localized if
necessary by developers.
  * The error might contain the attempted value to allow redisplaying the correct value on the
UI.

* Adds support for reporting errors in Blazor. ModelBindingContext captures the errors and the
attempted values during the binding process and makes them available to the application.
* Updated the FormValueSupplier API to better integrate with model binding.
* Removed the need for CanConvertSingleValue.
* We now use the parameter name as part of the path to bind the parameter, for simple and
complex values.
* Updated CanBind to enable calling it without a form name when we just want to determine if
a given type is bindable.
* Updated the TryBind API to Bind and passed in a context object instead of multiple parameters.
* Integrates with EditForm and EditContext:
  * Automatically wire up the a validator to invalidate the form in the presence of errors.
  * Populates Input elements with the attempted value when possible after binding failed.

Author: javiercn

src/Components/Authorization/test/AuthorizeRouteViewTest.cs

@@ -472,20 +472,7 @@ public TestNavigationManager()
 
     private class TestFormValueSupplier : IFormValueSupplier
     {
-        public bool CanBind(string formName, Type valueType)
-        {
-            return false;
-        }
-
-        public bool CanConvertSingleValue(Type type)
-        {
-            return false;
-        }
-
-        public bool TryBind(string formName, Type valueType, [NotNullWhen(true)] out object boundValue)
-        {
-            boundValue = null;
-            return false;
-        }
+        public bool CanBind(Type valueType, string formName = null) => false;
+        public void Bind(FormValueSupplierContext context) { }
     }
 }

src/Components/Components/src/Binding/BindingError.cs

@@ -0,0 +1,83 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Components;
+
+/// <summary>
+/// An error that occurred during the form mapping process.
+/// </summary>
+public class BindingError
+{
+    private static readonly char[] Separators = new char[] { '.', '[' };
+    private readonly List<FormattableString> _errorMessages;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="BindingError"/>.
+    /// </summary>
+    /// <param name="path">The path from the root of the binding operation to the property or element that failed to bind.</param>
+    /// <param name="errorMessages">The error messages associated with the binding error.</param>
+    /// <param name="attemptedValue">The attempted value that failed to bind.</param>
+    internal BindingError(string path, List<FormattableString> errorMessages, string? attemptedValue)
+    {
+        _errorMessages = errorMessages;
+        AttemptedValue = attemptedValue;
+        Path = path;
+        Name = GetName(Path);
+    }
+
+    /// <summary>
+    /// Gets or sets the instance that contains the property or element that failed to bind.
+    /// </summary>
+    /// <remarks>
+    /// For object models, this is the instance of the object that contains the property that failed to bind.
+    /// For collection models, this is the collection instance that contains the element that failed to bind.
+    /// For dictionaries, this is the dictionary instance that contains the element that failed to bind.
+    /// </remarks>
+    public object Container { get; internal set; } = null!;
+
+    /// <summary>
+    /// Gets or sets the name of the property or element that failed to bind.
+    /// </summary>
+    public string Name { get; }
+
+    /// <summary>
+    /// Gets or sets the full path from the model root to the property or element that failed to bind.
+    /// </summary>
+    public string Path { get; }
+
+    /// <summary>
+    /// Gets the list of error messages associated with the binding errors for this field.
+    /// </summary>
+    public IReadOnlyList<FormattableString> ErrorMessages => _errorMessages;
+
+    /// <summary>
+    /// Gets the attempted value that failed to bind (if any).
+    /// </summary>
+    public string? AttemptedValue { get; }
+
+    private static string GetName(string path)
+    {
+        var errorKey = path;
+        var lastSeparatorIndex = path.LastIndexOfAny(Separators);
+        if (lastSeparatorIndex >= 0)
+        {
+            if (path[lastSeparatorIndex] == '[')
+            {
+                var closingBracket = path.IndexOf(']', lastSeparatorIndex);
+                // content within brackets
+                errorKey = path[(lastSeparatorIndex + 1)..closingBracket];
+            }
+            else
+            {
+                errorKey = path[(lastSeparatorIndex + 1)..];
+            }
+        }
+
+        return errorKey;
+    }
+
+    internal void AddError(FormattableString error)
+    {
+        _errorMessages.Add(error);
+    }
+}

src/Components/Components/src/Binding/CascadingModelBinder.cs

@@ -132,7 +132,8 @@ _bindingContext is null ||
                 throw new InvalidOperationException($"'{nameof(CascadingModelBinder)}' 'Name' can't change after initialized.");
             }
 
-            _bindingContext = new ModelBindingContext(name, bindingId, CanBind);
+            _bindingContext = new ModelBindingContext(name, bindingId);
+            ParentContext?.SetErrors(name, _bindingContext);
         }
 
         string GenerateBindingContextId(string name)
@@ -141,19 +142,6 @@ string GenerateBindingContextId(string name)
             var hashIndex = bindingId.IndexOf('#');
             return hashIndex == -1 ? bindingId : new string(bindingId.AsSpan(0, hashIndex));
         }
-
-        bool CanBind(Type type)
-        {
-            foreach (var provider in ModelBindingProviders)
-            {
-                if (provider.SupportsParameterType(type))
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
     }
 
     bool ICascadingValueSupplier.CanSupplyValue(in CascadingParameterInfo parameterInfo)

src/Components/Components/src/Binding/FormValueSupplierContext.cs

@@ -0,0 +1,80 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Components.Binding;
+
+/// <summary>
+/// Context for binding a form value.
+/// </summary>
+public class FormValueSupplierContext
+{
+    private bool _resultSet;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="FormValueSupplierContext"/>.
+    /// </summary>
+    /// <param name="formName">The name of the form to bind data from.</param>
+    /// <param name="valueType">The <see cref="Type"/> of the value to bind.</param>
+    /// <param name="parameterName">The name of the parameter to bind data to.</param>
+    public FormValueSupplierContext(
+        string formName,
+        Type valueType,
+        string parameterName)
+    {
+        ArgumentNullException.ThrowIfNull(formName, nameof(formName));
+        ArgumentNullException.ThrowIfNull(valueType, nameof(valueType));
+        ArgumentNullException.ThrowIfNull(parameterName, nameof(parameterName));
+        FormName = formName;
+        ParameterName = parameterName;
+        ValueType = valueType;
+    }
+
+    /// <summary>
+    /// Gets the name of the form to bind data from.
+    /// </summary>
+    public string FormName { get; }
+
+    /// <summary>
+    /// Gets the name of the parameter to bind data to.
+    /// </summary>
+    public string ParameterName { get; }
+
+    /// <summary>
+    /// Gets the <see cref="Type"/> of the value to bind.
+    /// </summary>
+    public Type ValueType { get; }
+
+    /// <summary>
+    /// Gets the callback to invoke when an error occurs.
+    /// </summary>
+    public Action<string, FormattableString, string?>? OnError { get; set; }
+
+    /// <summary>
+    /// Maps a set of errors to a concrete containing instance.
+    /// </summary>
+    /// <remarks>
+    /// For example, maps errors for a given property in a class to the class instance.
+    /// This is required so that validation can work without the need of the full identifier.
+    /// </remarks>
+    public Action<string, object>? MapErrorToContainer { get; set; }
+
+    /// <summary>
+    /// Gets the result of the binding operation.
+    /// </summary>
+    public object? Result { get; private set; }
+
+    /// <summary>
+    /// Sets the result of the binding operation.
+    /// </summary>
+    /// <param name="result">The result of the binding operation.</param>
+    /// <exception cref="InvalidOperationException">Thrown if the result has already been set.</exception>
+    public void SetResult(object? result)
+    {
+        if (_resultSet)
+        {
+            throw new InvalidOperationException($"The result has already been set to '{Result}'.");
+        }
+        _resultSet = true;
+        Result = result;
+    }
+}

src/Components/Components/src/Binding/IFormValueSupplier.cs

@@ -1,8 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Diagnostics.CodeAnalysis;
-
 namespace Microsoft.AspNetCore.Components.Binding;
 
 /// <summary>
@@ -13,25 +11,14 @@ public interface IFormValueSupplier
     /// <summary>
     /// Determines whether the specified value type can be bound.
     /// </summary>
-    /// <param name="formName">The form name to bind data from.</param>
     /// <param name="valueType">The <see cref="Type"/> for the value to bind.</param>
+    /// <param name="formName">The form name to bind data from or null to only validate the type can be bound.</param>
     /// <returns><c>true</c> if the value type can be bound; otherwise, <c>false</c>.</returns>
-    bool CanBind(string formName, Type valueType);
+    bool CanBind(Type valueType, string? formName = null);
 
     /// <summary>
-    /// Determines whether a given <see cref="Type"/> can be converted from a single string value.
-    /// For example, strings, numbers, boolean values, enums, guids, etc. fall in this category.
+    /// Binds the form with the specified name to a value of the specified type.
+    /// <param name="context">The <see cref="FormValueSupplierContext"/>.</param>
     /// </summary>
-    /// <param name="type">The <see cref="Type"/> to check.</param>
-    /// <returns><c>true</c> if the type can be converted from a single string value; otherwise, <c>false</c>.</returns>
-    bool CanConvertSingleValue(Type type);
-
-    /// <summary>
-    /// Tries to bind the form with the specified name to a value of the specified type.
-    /// </summary>
-    /// <param name="formName">The form name to bind data from.</param>
-    /// <param name="valueType">The <see cref="Type"/> for the value to bind.</param>
-    /// <param name="boundValue">The bound value if succeeded.</param>
-    /// <returns><c>true</c> if the form was bound successfully; otherwise, <c>false</c>.</returns>
-    bool TryBind(string formName, Type valueType, [NotNullWhen(true)] out object? boundValue);
+    void Bind(FormValueSupplierContext context);
 }