Limit types supported by NullableConverterFactory

Author: oroztocil

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

@@ -41,7 +41,7 @@ public bool TryConvertValue(ref FormDataReader reader, string value, out T? resu
     [RequiresUnreferencedCode(FormMappingHelpers.RequiresUnreferencedCodeMessage)]
     internal override bool TryRead(ref FormDataReader reader, Type type, FormDataMapperOptions options, out T? result, out bool found)
     {
-        // Donot call non-nullable converter's TryRead method, it will fail to parse empty
+        // Do not call non-nullable converter's TryRead method, it will fail to parse empty
         // string. Call the TryConvertValue method above (similar to ParsableConverter) so
         // that it can handle the empty string correctly
         found = reader.TryGetValue(out var value);

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

@@ -15,7 +15,13 @@ internal sealed class NullableConverterFactory : IFormDataConverterFactory
     public bool CanConvert(Type type, FormDataMapperOptions options)
     {
         var underlyingType = Nullable.GetUnderlyingType(type);
-        return underlyingType != null && options.ResolveConverter(underlyingType) != null;
+
+        if (underlyingType == null)
+        {
+            return false;
+        }
+
+        return IsSupportedUnderlyingType(underlyingType) && options.ResolveConverter(underlyingType) != null;
     }
 
     [RequiresDynamicCode(FormMappingHelpers.RequiresDynamicCodeMessage)]
@@ -24,6 +30,7 @@ public FormDataConverter CreateConverter(Type type, FormDataMapperOptions option
     {
         var underlyingType = Nullable.GetUnderlyingType(type);
         Debug.Assert(underlyingType != null);
+        Debug.Assert(IsSupportedUnderlyingType(underlyingType));
 
         var underlyingConverter = options.ResolveConverter(underlyingType);
         Debug.Assert(underlyingConverter != null);
@@ -34,4 +41,14 @@ public FormDataConverter CreateConverter(Type type, FormDataMapperOptions option
         return Activator.CreateInstance(expectedConverterType, underlyingConverter) as FormDataConverter ??
             throw new InvalidOperationException($"Unable to create converter for type '{type}'.");
     }
+
+    private static bool IsSupportedUnderlyingType(Type type)
+    {
+        return Type.GetTypeCode(type) != TypeCode.Object || IsSupportedUnderlyingObjectType(type);
+    }
+
+    private static bool IsSupportedUnderlyingObjectType(Type type)
+    {
+        return type == typeof(DateOnly) || type == typeof(TimeOnly) || type == typeof(DateTimeOffset);
+    }
 }

src/Components/Endpoints/test/FormMapping/Factories/NullableConverterFactoryTests.cs

@@ -0,0 +1,54 @@
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.AspNetCore.Components.Endpoints.FormMapping;
+
+namespace Microsoft.AspNetCore.Components.Endpoints.Tests.FormMapping.Factories;
+
+public class NullableConverterFactoryTests
+{
+    [Fact]
+    public void CanConvert_ReturnsFalseForNonParsableStruct()
+    {
+        var factory = NullableConverterFactory.Instance;
+        var options = new FormDataMapperOptions();
+        var result = factory.CanConvert(typeof(NonParsableTestStruct?), options);
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void CanConvert_ReturnsFalseForParsableStruct()
+    {
+        var factory = NullableConverterFactory.Instance;
+        var options = new FormDataMapperOptions();
+        var result = factory.CanConvert(typeof(ParsableTestStruct?), options);
+        Assert.False(result);
+    }
+
+    [Theory]
+    [InlineData(typeof(DateOnly?))]
+    [InlineData(typeof(TimeOnly?))]
+    [InlineData(typeof(DateTimeOffset?))]
+    public void CanConvert_ReturnsTrueForSupportedObjectTypes(Type type)
+    {
+        var factory = NullableConverterFactory.Instance;
+        var options = new FormDataMapperOptions();
+        var result = factory.CanConvert(type, options);
+        Assert.True(result);
+    }
+
+    private struct NonParsableTestStruct
+    {
+    }
+
+    private struct ParsableTestStruct : IParsable<ParsableTestStruct>
+    {
+        public static ParsableTestStruct Parse(string s, IFormatProvider provider)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static bool TryParse([NotNullWhen(true)] string s, IFormatProvider provider, [MaybeNullWhen(false)] out ParsableTestStruct result)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}