Fix MVC form data binding localization

src/Mvc/Mvc.Core/src/ModelBinding/FormValueProvider.cs

@@ -13,7 +13,10 @@ namespace Microsoft.AspNetCore.Mvc.ModelBinding;
 /// </summary>
 public class FormValueProvider : BindingSourceValueProvider, IEnumerableValueProvider
 {
+    internal const string CultureInvariantFieldName = "__Invariant";
+
     private readonly IFormCollection _values;
+    private readonly HashSet<string?>? _invariantValueKeys;
     private PrefixContainer? _prefixContainer;
 
     /// <summary>
@@ -39,6 +42,12 @@ public FormValueProvider(
         }
 
         _values = values;
+
+        if (_values.TryGetValue(CultureInvariantFieldName, out var invariantKeys) && invariantKeys.Count > 0)
+        {
+            _invariantValueKeys = new(invariantKeys, StringComparer.OrdinalIgnoreCase);
+        }
+
         Culture = culture;
     }
 
@@ -104,7 +113,8 @@ public override ValueProviderResult GetValue(string key)
         }
         else
         {
-            return new ValueProviderResult(values, Culture);
+            var culture = _invariantValueKeys?.Contains(key) == true ? CultureInfo.InvariantCulture : Culture;
+            return new ValueProviderResult(values, culture);
         }
     }
 }

src/Mvc/Mvc.Core/src/ModelBinding/JQueryFormValueProvider.cs

@@ -13,6 +13,8 @@ namespace Microsoft.AspNetCore.Mvc.ModelBinding;
 /// </summary>
 public class JQueryFormValueProvider : JQueryValueProvider
 {
+    private readonly HashSet<string?>? _invariantValueKeys;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="JQueryFormValueProvider"/> class.
     /// </summary>
@@ -25,5 +27,22 @@ public JQueryFormValueProvider(
         CultureInfo? culture)
         : base(bindingSource, values, culture)
     {
+        if (values.TryGetValue(FormValueProvider.CultureInvariantFieldName, out var invariantKeys) && invariantKeys.Count > 0)
+        {
+            _invariantValueKeys = new(invariantKeys, StringComparer.OrdinalIgnoreCase);
+        }
+    }
+
+    /// <inheritdoc/>
+    public override ValueProviderResult GetValue(string key)
+    {
+        var result = base.GetValue(key);
+
+        if (result.Length > 0 && _invariantValueKeys?.Contains(key) == true)
+        {
+            return new(result.Values, CultureInfo.InvariantCulture);
+        }
+
+        return result;
     }
 }

src/Mvc/Mvc.Core/src/PublicAPI.Unshipped.txt

@@ -30,6 +30,7 @@ Microsoft.AspNetCore.Mvc.ModelBinding.Metadata.SystemTextJsonValidationMetadataP
 Microsoft.AspNetCore.Mvc.ModelBinding.Metadata.SystemTextJsonValidationMetadataProvider.SystemTextJsonValidationMetadataProvider(System.Text.Json.JsonNamingPolicy! namingPolicy) -> void
 Microsoft.AspNetCore.Mvc.ModelBinding.Metadata.ValidationMetadata.ValidationModelName.get -> string?
 Microsoft.AspNetCore.Mvc.ModelBinding.Metadata.ValidationMetadata.ValidationModelName.set -> void
+override Microsoft.AspNetCore.Mvc.ModelBinding.JQueryFormValueProvider.GetValue(string! key) -> Microsoft.AspNetCore.Mvc.ModelBinding.ValueProviderResult
 virtual Microsoft.AspNetCore.Mvc.Infrastructure.ConfigureCompatibilityOptions<TOptions>.PostConfigure(string? name, TOptions! options) -> void
 static Microsoft.AspNetCore.Mvc.ControllerBase.Empty.get -> Microsoft.AspNetCore.Mvc.EmptyResult!
 *REMOVED*virtual Microsoft.AspNetCore.Mvc.ModelBinding.DefaultPropertyFilterProvider<TModel>.PropertyIncludeExpressions.get -> System.Collections.Generic.IEnumerable<System.Linq.Expressions.Expression<System.Func<TModel!, object!>!>!>?

src/Mvc/Mvc.Core/test/ModelBinding/FormValueProviderTest.cs

@@ -9,6 +9,31 @@ namespace Microsoft.AspNetCore.Mvc.ModelBinding;
 
 public class FormValueProviderTest : EnumerableValueProviderTest
 {
+    [Fact]
+    public void GetValue_ReturnsInvariantCulture_IfInvariantEntryExists()
+    {
+        // Arrange
+        var culture = new CultureInfo("fr-FR");
+        var invariantCultureKey = "prefix.name";
+        var currentCultureKey = "some";
+        var values = new Dictionary<string, StringValues>(BackingStore)
+        {
+            { FormValueProvider.CultureInvariantFieldName, new(invariantCultureKey) },
+        };
+        var valueProvider = GetEnumerableValueProvider(BindingSource.Query, values, culture);
+
+        // Act
+        var invariantCultureResult = valueProvider.GetValue(invariantCultureKey);
+        var currentCultureResult = valueProvider.GetValue(currentCultureKey);
+
+        // Assert
+        Assert.Equal(CultureInfo.InvariantCulture, invariantCultureResult.Culture);
+        Assert.Equal(BackingStore[invariantCultureKey], invariantCultureResult.Values);
+
+        Assert.Equal(culture, currentCultureResult.Culture);
+        Assert.Equal(BackingStore[currentCultureKey], currentCultureResult.Values);
+    }
+
     protected override IEnumerableValueProvider GetEnumerableValueProvider(
         BindingSource bindingSource,
         Dictionary<string, StringValues> values,

src/Mvc/Mvc.Core/test/ModelBinding/JQueryFormValueProviderTest.cs

@@ -46,4 +46,29 @@ public override void GetValue_EmptyKey()
         // Assert
         Assert.Equal("some-value", (string)result);
     }
+
+    [Fact]
+    public void GetValue_ReturnsInvariantCulture_IfInvariantEntryExists()
+    {
+        // Arrange
+        var culture = new CultureInfo("fr-FR");
+        var invariantCultureKey = "prefix.name";
+        var currentCultureKey = "some";
+        var values = new Dictionary<string, StringValues>(BackingStore)
+        {
+            { FormValueProvider.CultureInvariantFieldName, new(invariantCultureKey) },
+        };
+        var valueProvider = GetEnumerableValueProvider(BindingSource.Query, values, culture);
+
+        // Act
+        var invariantCultureResult = valueProvider.GetValue(invariantCultureKey);
+        var currentCultureResult = valueProvider.GetValue(currentCultureKey);
+
+        // Assert
+        Assert.Equal(CultureInfo.InvariantCulture, invariantCultureResult.Culture);
+        Assert.Equal(BackingStore[invariantCultureKey], invariantCultureResult.Values);
+
+        Assert.Equal(culture, currentCultureResult.Culture);
+        Assert.Equal(BackingStore[currentCultureKey], currentCultureResult.Values);
+    }
 }

src/Mvc/Mvc.TagHelpers/src/InputTagHelper.cs

@@ -243,8 +243,18 @@ public override void Process(TagHelperContext context, TagHelperOutput output)
 
         if (tagBuilder != null)
         {
-            // This TagBuilder contains the one <input/> element of interest.
+            // This TagBuilder contains the primary <input/> element of interest.
             output.MergeAttributes(tagBuilder);
+
+            if (tagBuilder.Attributes.TryGetValue("name", out var fullName) &&
+                ViewContext.FormContext.InvariantField(fullName))
+            {
+                // If the value attribute used culture-invariant formatting, output a hidden
+                // <input/> element so the form submission includes an entry indicating such.
+                // This lets the model binding logic decide which CultureInfo to use when parsing form entries.
+                GenerateInvariantCultureMetadata(fullName, output.PostElement);
+            }
+
             if (tagBuilder.HasInnerHtml)
             {
                 // Since this is not the "checkbox" special-case, no guarantee that output is a self-closing
@@ -410,6 +420,14 @@ private TagBuilder GenerateTextBox(
             htmlAttributes);
     }
 
+    private static void GenerateInvariantCultureMetadata(string propertyName, TagHelperContent builder)
+        => builder
+            .AppendHtml("<input name=\"")
+            .Append(FormValueProvider.CultureInvariantFieldName)
+            .AppendHtml("\" type=\"hidden\" value=\"")
+            .Append(propertyName)
+            .AppendHtml("\" />");
+
     // Imitate Generator.GenerateHidden() using Generator.GenerateTextBox(). This adds support for asp-format that
     // is not available in Generator.GenerateHidden().
     private TagBuilder GenerateHidden(ModelExplorer modelExplorer, IDictionary<string, object> htmlAttributes)

src/Mvc/Mvc.TagHelpers/test/InputTagHelperTest.cs

@@ -833,6 +833,75 @@ public void Process_GeneratesFormattedOutput_ForDateTime(string specifiedType, s
         Assert.Equal(expectedTagName, output.TagName);
     }
 
+    [Theory]
+    [InlineData("SomeProperty", "SomeProperty", true)]
+    [InlineData("SomeProperty", "[0].SomeProperty", true)]
+    [InlineData("SomeProperty", "[0].SomeProperty", false)]
+    public void Process_GeneratesInvariantCultureMetadataInput_WhenValueUsesInvariantFormatting(string propertyName, string nameAttributeValue, bool usesInvariantFormatting)
+    {
+        // Arrange
+        var metadataProvider = new EmptyModelMetadataProvider();
+        var htmlGenerator = new Mock<IHtmlGenerator>(MockBehavior.Strict);
+        var model = false;
+        var modelExplorer = metadataProvider.GetModelExplorerForType(typeof(bool), model);
+        var modelExpression = new ModelExpression(name: string.Empty, modelExplorer: modelExplorer);
+        var viewContext = TestableHtmlGenerator.GetViewContext(model, htmlGenerator.Object, metadataProvider);
+        var tagHelper = new InputTagHelper(htmlGenerator.Object)
+        {
+            For = modelExpression,
+            InputTypeName = "text",
+            Name = propertyName,
+            ViewContext = viewContext,
+        };
+
+        var tagBuilder = new TagBuilder("input")
+        {
+            TagRenderMode = TagRenderMode.SelfClosing,
+            Attributes =
+            {
+                { "name", nameAttributeValue },
+            },
+        };
+
+        htmlGenerator
+            .Setup(mock => mock.GenerateTextBox(
+                tagHelper.ViewContext,
+                tagHelper.For.ModelExplorer,
+                tagHelper.For.Name,
+                modelExplorer.Model,
+                null,                   // format
+                It.IsAny<object>()))    // htmlAttributes
+            .Returns(tagBuilder)
+            .Callback(() => viewContext.FormContext.InvariantField(tagBuilder.Attributes["name"], usesInvariantFormatting))
+            .Verifiable();
+
+        var expectedPostElement = usesInvariantFormatting
+            ? $"<input name=\"__Invariant\" type=\"hidden\" value=\"{tagBuilder.Attributes["name"]}\" />"
+            : string.Empty;
+
+        var attributes = new TagHelperAttributeList
+            {
+                { "name", propertyName },
+                { "type", "text" },
+            };
+        var context = new TagHelperContext(attributes, new Dictionary<object, object>(), "test");
+        var output = new TagHelperOutput(
+            "input",
+            new TagHelperAttributeList(),
+            getChildContentAsync: (useCachedResult, encoder) => Task.FromResult<TagHelperContent>(result: null))
+        {
+            TagMode = TagMode.SelfClosing,
+        };
+
+        // Act
+        tagHelper.Process(context, output);
+
+        // Assert
+        htmlGenerator.Verify();
+
+        Assert.Equal(expectedPostElement, output.PostElement.GetContent());
+    }
+
     [Fact]
     public async Task ProcessAsync_GenerateCheckBox_WithHiddenInputRenderModeNone()
     {

src/Mvc/Mvc.ViewFeatures/src/DefaultHtmlGenerator.cs

@@ -40,6 +40,7 @@ public class DefaultHtmlGenerator : IHtmlGenerator
     private readonly IUrlHelperFactory _urlHelperFactory;
     private readonly HtmlEncoder _htmlEncoder;
     private readonly ValidationHtmlAttributeProvider _validationAttributeProvider;
+    private readonly FormInputRenderMode _formInputRenderMode;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="DefaultHtmlGenerator"/> class.
@@ -94,6 +95,7 @@ public DefaultHtmlGenerator(
         _urlHelperFactory = urlHelperFactory;
         _htmlEncoder = htmlEncoder;
         _validationAttributeProvider = validationAttributeProvider;
+        _formInputRenderMode = optionsAccessor.Value.HtmlHelperOptions.FormInputRenderMode;
 
         // Underscores are fine characters in id's.
         IdAttributeDotReplacement = optionsAccessor.Value.HtmlHelperOptions.IdAttributeDotReplacement;
@@ -134,7 +136,12 @@ public string Encode(object value)
     /// <inheritdoc />
     public string FormatValue(object value, string format)
     {
-        return ViewDataDictionary.FormatValue(value, format);
+        return ViewDataDictionary.FormatValue(value, format, CultureInfo.CurrentCulture);
+    }
+
+    private static string FormatValue(object value, string format, IFormatProvider formatProvider)
+    {
+        return ViewDataDictionary.FormatValue(value, format, formatProvider);
     }
 
     /// <inheritdoc />
@@ -1282,7 +1289,18 @@ protected virtual TagBuilder GenerateInput(
             AddMaxLengthAttribute(viewContext.ViewData, tagBuilder, modelExplorer, expression);
         }
 
-        var valueParameter = FormatValue(value, format);
+        CultureInfo culture;
+        if (ShouldUseInvariantFormattingForInputType(suppliedTypeString, viewContext.Html5DateRenderingMode))
+        {
+            culture = CultureInfo.InvariantCulture;
+            viewContext.FormContext.InvariantField(fullName, true);
+        }
+        else
+        {
+            culture = CultureInfo.CurrentCulture;
+        }
+
+        var valueParameter = FormatValue(value, format, culture);
         var usedModelState = false;
         switch (inputType)
         {
@@ -1329,27 +1347,15 @@ protected virtual TagBuilder GenerateInput(
 
             case InputType.Text:
             default:
-                var attributeValue = (string)GetModelStateValue(viewContext, fullName, typeof(string));
-                if (attributeValue == null)
+                if (string.Equals(suppliedTypeString, "file", StringComparison.OrdinalIgnoreCase) ||
+                    string.Equals(suppliedTypeString, "image", StringComparison.OrdinalIgnoreCase))
                 {
-                    attributeValue = useViewData ? EvalString(viewContext, expression, format) : valueParameter;
+                    // 'value' attribute is not needed for 'file' and 'image' input types.
                 }
-
-                var addValue = true;
-                object typeAttributeValue;
-                if (htmlAttributes != null && htmlAttributes.TryGetValue("type", out typeAttributeValue))
-                {
-                    var typeAttributeString = typeAttributeValue.ToString();
-                    if (string.Equals(typeAttributeString, "file", StringComparison.OrdinalIgnoreCase) ||
-                        string.Equals(typeAttributeString, "image", StringComparison.OrdinalIgnoreCase))
-                    {
-                        // 'value' attribute is not needed for 'file' and 'image' input types.
-                        addValue = false;
-                    }
-                }
-
-                if (addValue)
+                else
                 {
+                    var attributeValue = (string)GetModelStateValue(viewContext, fullName, typeof(string));
+                    attributeValue ??= useViewData ? EvalString(viewContext, expression, format) : valueParameter;
                     tagBuilder.MergeAttribute("value", attributeValue, replaceExisting: isExplicitValue);
                 }
 
@@ -1556,6 +1562,38 @@ private static string GetInputTypeString(InputType inputType)
         }
     }
 
+    private bool ShouldUseInvariantFormattingForInputType(string inputType, Html5DateRenderingMode dateRenderingMode)
+    {
+        if (_formInputRenderMode == FormInputRenderMode.DetectCultureFromInputType)
+        {
+            var isNumberInput =
+                string.Equals(inputType, "number", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(inputType, "range", StringComparison.OrdinalIgnoreCase);
+
+            if (isNumberInput)
+            {
+                return true;
+            }
+
+            if (dateRenderingMode != Html5DateRenderingMode.CurrentCulture)
+            {
+                var isDateInput =
+                    string.Equals(inputType, "date", StringComparison.OrdinalIgnoreCase) ||
+                    string.Equals(inputType, "datetime-local", StringComparison.OrdinalIgnoreCase) ||
+                    string.Equals(inputType, "month", StringComparison.OrdinalIgnoreCase) ||
+                    string.Equals(inputType, "time", StringComparison.OrdinalIgnoreCase) ||
+                    string.Equals(inputType, "week", StringComparison.OrdinalIgnoreCase);
+
+                if (isDateInput)
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     private static IEnumerable<SelectListItem> GetSelectListItems(
         ViewContext viewContext,
         string expression)