[Blazor] Support for primitive types in [SupplyParameterFromForm]

src/Components/Authorization/test/AuthorizeRouteViewTest.cs

@@ -478,6 +478,11 @@ 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;

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

@@ -114,7 +114,7 @@ internal void UpdateBindingInformation(string url)
         var bindingContext = _bindingContext != null &&
             string.Equals(_bindingContext.Name, name, StringComparison.Ordinal) &&
             string.Equals(_bindingContext.BindingContextId, bindingId, StringComparison.Ordinal) ?
-            _bindingContext : new ModelBindingContext(name, bindingId);
+            _bindingContext : new ModelBindingContext(name, bindingId, FormValueSupplier.CanConvertSingleValue);
 
         // It doesn't matter that we don't check IsFixed, since the CascadingValue we are setting up will throw if the app changes.
         if (IsFixed && _bindingContext != null && _bindingContext != bindingContext)

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

@@ -18,6 +18,14 @@ public interface IFormValueSupplier
     /// <returns><c>true</c> if the value type can be bound; otherwise, <c>false</c>.</returns>
     bool CanBind(string formName, Type valueType);
 
+    /// <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.
+    /// </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>

src/Components/Components/src/Binding/ModelBindingContext.cs

@@ -8,10 +8,13 @@ namespace Microsoft.AspNetCore.Components;
 /// </summary>
 public sealed class ModelBindingContext
 {
-    internal ModelBindingContext(string name, string bindingContextId)
+    private readonly Predicate<Type> _canBind;
+
+    internal ModelBindingContext(string name, string bindingContextId, Predicate<Type> canBind)
     {
         ArgumentNullException.ThrowIfNull(name);
         ArgumentNullException.ThrowIfNull(bindingContextId);
+        ArgumentNullException.ThrowIfNull(canBind);
         // We are initializing the root context, that can be a "named" root context, or the default context.
         // A named root context only provides a name, and that acts as the BindingId
         // A "default" root context does not provide a name, and instead it provides an explicit Binding ID.
@@ -23,6 +26,7 @@ internal ModelBindingContext(string name, string bindingContextId)
 
         Name = name;
         BindingContextId = bindingContextId ?? name;
+        _canBind = canBind;
     }
 
     /// <summary>
@@ -37,4 +41,9 @@ internal ModelBindingContext(string name, string bindingContextId)
 
     internal static string Combine(ModelBindingContext? parentContext, string name) =>
         string.IsNullOrEmpty(parentContext?.Name) ? name : $"{parentContext.Name}.{name}";
+
+    internal bool CanConvert(Type type)
+    {
+        return _canBind(type);
+    }
 }

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

@@ -2,6 +2,7 @@
 abstract Microsoft.AspNetCore.Components.RenderModeAttribute.Mode.get -> Microsoft.AspNetCore.Components.IComponentRenderMode!
 Microsoft.AspNetCore.Components.Binding.IFormValueSupplier
 Microsoft.AspNetCore.Components.Binding.IFormValueSupplier.CanBind(string! formName, System.Type! valueType) -> bool
+Microsoft.AspNetCore.Components.Binding.IFormValueSupplier.CanConvertSingleValue(System.Type! type) -> bool
 Microsoft.AspNetCore.Components.Binding.IFormValueSupplier.TryBind(string! formName, System.Type! valueType, out object? boundValue) -> bool
 Microsoft.AspNetCore.Components.CascadingModelBinder
 Microsoft.AspNetCore.Components.CascadingModelBinder.CascadingModelBinder() -> void

src/Components/Components/test/CascadingModelBinderTest.cs

@@ -338,6 +338,11 @@ 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;

src/Components/Components/test/CascadingParameterStateTest.cs

@@ -535,6 +535,11 @@ public bool CanBind(string formName, Type valueType)
                 valueType == ValueType;
         }
 
+        public bool CanConvertSingleValue(Type type)
+        {
+            return type == ValueType;
+        }
+
         public bool TryBind(string formName, Type valueType, [NotNullWhen(true)] out object boundValue)
         {
             boundValue = BoundValue;

src/Components/Components/test/ModelBindingContextTest.cs

@@ -8,30 +8,30 @@ public class ModelBindingContextTest
     [Fact]
     public void CanCreate_BindingContext_WithDefaultName()
     {
-        var context = new ModelBindingContext("", "");
+        var context = new ModelBindingContext("", "", t => true);
         Assert.Equal("", context.Name);
         Assert.Equal("", context.BindingContextId);
     }
 
     [Fact]
     public void CanCreate_BindingContext_WithName()
     {
-        var context = new ModelBindingContext("name", "path?handler=name");
+        var context = new ModelBindingContext("name", "path?handler=name", t => true);
         Assert.Equal("name", context.Name);
         Assert.Equal("path?handler=name", context.BindingContextId);
     }
 
     [Fact]
     public void Throws_WhenNameIsProvided_AndNoBindingContextId()
     {
-        var exception = Assert.Throws<InvalidOperationException>(() => new ModelBindingContext("name", ""));
+        var exception = Assert.Throws<InvalidOperationException>(() => new ModelBindingContext("name", "", t => true));
         Assert.Equal("A root binding context needs to provide a name and explicit binding context id or none.", exception.Message);
     }
 
     [Fact]
     public void Throws_WhenBindingContextId_IsProvidedForDefaultName()
     {
-        var exception = Assert.Throws<InvalidOperationException>(() => new ModelBindingContext("", "context"));
+        var exception = Assert.Throws<InvalidOperationException>(() => new ModelBindingContext("", "context", t => true));
         Assert.Equal("A root binding context needs to provide a name and explicit binding context id or none.", exception.Message);
     }
 }

src/Components/Components/test/RouteViewTest.cs

@@ -248,6 +248,11 @@ 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;

src/Components/Endpoints/src/Binding/Converters/NullableConverter.cs

@@ -0,0 +1,28 @@
+// 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.Endpoints.Binding;
+
+internal sealed class NullableConverter<T> : FormDataConverter<T?> where T : struct
+{
+    private readonly FormDataConverter<T> _nonNullableConverter;
+
+    public NullableConverter(FormDataConverter<T> nonNullableConverter)
+    {
+        _nonNullableConverter = nonNullableConverter;
+    }
+
+    internal override bool TryRead(ref FormDataReader context, Type type, FormDataMapperOptions options, out T? result, out bool found)
+    {
+        if (!(_nonNullableConverter.TryRead(ref context, type, options, out var innerResult, out found) && found))
+        {
+            result = null;
+            return false;
+        }
+        else
+        {
+            result = innerResult;
+            return true;
+        }
+    }
+}

src/Components/Endpoints/src/Binding/Converters/ParsableConverter.cs

@@ -0,0 +1,21 @@
+// 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.Endpoints.Binding;
+
+internal sealed class ParsableConverter<T> : FormDataConverter<T>, ISingleValueConverter where T : IParsable<T>
+{
+    internal override bool TryRead(ref FormDataReader reader, Type type, FormDataMapperOptions options, out T? result, out bool found)
+    {
+        found = reader.TryGetValue(out var value);
+        if (found && T.TryParse(value, reader.Culture, out result))
+        {
+            return true;
+        }
+        else
+        {
+            result = default;
+            return false;
+        }
+    }
+}

src/Components/Endpoints/src/Binding/DefaultFormValuesSupplier.cs

@@ -1,52 +1,82 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Concurrent;
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Reflection;
 using Microsoft.AspNetCore.Components.Binding;
+using Microsoft.AspNetCore.Components.Endpoints.Binding;
 using Microsoft.AspNetCore.Components.Forms;
+using Microsoft.Extensions.Primitives;
 
 namespace Microsoft.AspNetCore.Components.Endpoints;
 
-internal class DefaultFormValuesSupplier : IFormValueSupplier
+internal sealed class DefaultFormValuesSupplier : IFormValueSupplier
 {
-    private readonly FormDataProvider _formData;
+    private static readonly MethodInfo _method = typeof(DefaultFormValuesSupplier)
+            .GetMethod(
+                nameof(DeserializeCore),
+                BindingFlags.NonPublic | BindingFlags.Static) ??
+            throw new InvalidOperationException($"Unable to find method '{nameof(DeserializeCore)}'.");
+
+    private readonly HttpContextFormDataProvider _formData;
+    private readonly FormDataMapperOptions _options = new();
+    private static readonly ConcurrentDictionary<Type, Func<IReadOnlyDictionary<string, StringValues>, FormDataMapperOptions, string, object>> _cache =
+        new();
 
     public DefaultFormValuesSupplier(FormDataProvider formData)
     {
-        _formData = formData;
+        _formData = (HttpContextFormDataProvider)formData;
     }
 
     public bool CanBind(string formName, Type valueType)
     {
         return _formData.IsFormDataAvailable &&
             string.Equals(formName, _formData.Name, StringComparison.Ordinal) &&
-            valueType == typeof(string);
+            _options.ResolveConverter(valueType) != null;
     }
 
     public bool TryBind(string formName, Type valueType, [NotNullWhen(true)] out object? boundValue)
     {
-        // This will delegate to a proper binder
+        // This will func to a proper binder
         if (!CanBind(formName, valueType))
         {
             boundValue = null;
             return false;
         }
 
-        if (!_formData.Entries.TryGetValue("value", out var rawValue) || rawValue.Count != 1)
-        {
-            boundValue = null;
-            return false;
-        }
-
-        var valueAsString = rawValue.ToString();
+        var deserializer = _cache.GetOrAdd(valueType, CreateDeserializer);
 
-        if (valueType == typeof(string))
+        var result = deserializer(_formData.Entries, _options, "value");
+        if (result != default)
         {
-            boundValue = valueAsString;
+            // This is not correct, but works for primtive values.
+            // Will change the interface when we add support for complex types.
+            boundValue = result;
             return true;
         }
 
-        boundValue = null;
+        boundValue = valueType.IsValueType ? Activator.CreateInstance(valueType) : null;
         return false;
     }
+
+    private Func<IReadOnlyDictionary<string, StringValues>, FormDataMapperOptions, string, object> CreateDeserializer(Type type) =>
+        _method.MakeGenericMethod(type)
+        .CreateDelegate<Func<IReadOnlyDictionary<string, StringValues>, FormDataMapperOptions, string, object>>();
+
+    private static object? DeserializeCore<T>(IReadOnlyDictionary<string, StringValues> form, FormDataMapperOptions options, string value)
+    {
+        // Form values are parsed according to the culture of the request, which is set to the current culture by the localization middleware.
+        // Some form input types use the invariant culture when sending the data to the server. For those cases, we'll
+        // provide a way to override the culture to use to parse that value.
+        var reader = new FormDataReader(form, CultureInfo.CurrentCulture);
+        reader.PushPrefix(value);
+        return FormDataMapper.Map<T>(reader, options);
+    }
+
+    public bool CanConvertSingleValue(Type type)
+    {
+        return _options.IsSingleValueConverter(type);
+    }
 }

src/Components/Endpoints/src/Binding/Factories/NullableConverterFactory.cs

@@ -0,0 +1,32 @@
+// 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;
+
+namespace Microsoft.AspNetCore.Components.Endpoints.Binding;
+
+internal sealed class NullableConverterFactory : IFormDataConverterFactory
+{
+    public static readonly NullableConverterFactory Instance = new();
+
+    public bool CanConvert(Type type, FormDataMapperOptions options)
+    {
+        var underlyingType = Nullable.GetUnderlyingType(type);
+        return underlyingType != null && options.ResolveConverter(underlyingType) != null;
+    }
+
+    public FormDataConverter CreateConverter(Type type, FormDataMapperOptions options)
+    {
+        var underlyingType = Nullable.GetUnderlyingType(type);
+        Debug.Assert(underlyingType != null);
+
+        var underlyingConverter = options.ResolveConverter(underlyingType);
+        Debug.Assert(underlyingConverter != null);
+
+        var expectedConverterType = typeof(NullableConverter<>).MakeGenericType(underlyingType);
+        Debug.Assert(expectedConverterType != null);
+
+        return Activator.CreateInstance(expectedConverterType, underlyingConverter) as FormDataConverter ??
+            throw new InvalidOperationException($"Unable to create converter for type '{type}'.");
+    }
+}

src/Components/Endpoints/src/Binding/Factories/ParsableConverterFactory.cs

@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.Internal;
+
+namespace Microsoft.AspNetCore.Components.Endpoints.Binding;
+
+internal sealed class ParsableConverterFactory : IFormDataConverterFactory
+{
+    public static readonly ParsableConverterFactory Instance = new();
+
+    public bool CanConvert(Type type, FormDataMapperOptions options)
+    {
+        return ClosedGenericMatcher.ExtractGenericInterface(type, typeof(IParsable<>)) is not null;
+    }
+
+    public FormDataConverter CreateConverter(Type type, FormDataMapperOptions options)
+    {
+        return Activator.CreateInstance(typeof(ParsableConverter<>).MakeGenericType(type)) as FormDataConverter ??
+            throw new InvalidOperationException($"Unable to create converter for '{type.FullName}'.");
+    }
+}

src/Components/Endpoints/src/Binding/FormDataConverter.cs

@@ -0,0 +1,9 @@
+// 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.Endpoints.Binding;
+
+// Base type for all types that can map from form data to a .NET type.
+internal class FormDataConverter
+{
+}

src/Components/Endpoints/src/Binding/FormDataConverterOfT.cs

@@ -0,0 +1,9 @@
+// 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.Endpoints.Binding;
+
+internal abstract class FormDataConverter<T> : FormDataConverter
+{
+    internal abstract bool TryRead(ref FormDataReader context, Type type, FormDataMapperOptions options, out T? result, out bool found);
+}