Binding primitive types

Author: javiercn

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/DefaultFormValuesSupplier.cs

@@ -1,15 +1,29 @@
 // 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
 {
+    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 FormDataProvider _formData;
+    private readonly FormDataSerializerOptions _options = new();
+    private static readonly ConcurrentDictionary<Type, Func<IReadOnlyDictionary<string, StringValues>, FormDataSerializerOptions, string, object>> _cache =
+        new();
 
     public DefaultFormValuesSupplier(FormDataProvider formData)
     {
@@ -20,33 +34,47 @@ public bool CanBind(string formName, Type valueType)
     {
         return _formData.IsFormDataAvailable &&
             string.Equals(formName, _formData.Name, StringComparison.Ordinal) &&
-            valueType == typeof(string);
+            _options.HasConverter(valueType);
     }
 
     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>, FormDataSerializerOptions, string, object> CreateDeserializer(Type type) =>
+        _method.MakeGenericMethod(type)
+        .CreateDelegate<Func<IReadOnlyDictionary<string, StringValues>, FormDataSerializerOptions, string, object>>();
+
+    private static object? DeserializeCore<T>(IReadOnlyDictionary<string, StringValues> form, FormDataSerializerOptions options, string value)
+    {
+        // Culture needs to come from the request.
+        var reader = new FormDataReader(form, CultureInfo.CurrentCulture);
+        reader.PushPrefix(value);
+        return FormDataDeserializer.Deserialize<T>(reader, options);
+    }
+
+    public bool CanConvertSingleValue(Type type)
+    {
+        return _options.IsSingleValueConverter(type);
+    }
 }