Respect JsonSerializerOptions casing for property names in validation errors

src/Http/Http.Abstractions/src/PublicAPI.Unshipped.txt

@@ -28,6 +28,8 @@ Microsoft.AspNetCore.Http.Validation.ValidateContext.ValidationContext.get -> Sy
 Microsoft.AspNetCore.Http.Validation.ValidateContext.ValidationContext.set -> void
 Microsoft.AspNetCore.Http.Validation.ValidateContext.ValidationErrors.get -> System.Collections.Generic.Dictionary<string!, string![]!>?
 Microsoft.AspNetCore.Http.Validation.ValidateContext.ValidationErrors.set -> void
+Microsoft.AspNetCore.Http.Validation.ValidateContext.SerializerOptions.get -> System.Text.Json.JsonSerializerOptions?
+Microsoft.AspNetCore.Http.Validation.ValidateContext.SerializerOptions.set -> void
 Microsoft.AspNetCore.Http.Validation.ValidateContext.ValidationOptions.get -> Microsoft.AspNetCore.Http.Validation.ValidationOptions!
 Microsoft.AspNetCore.Http.Validation.ValidateContext.ValidationOptions.set -> void
 Microsoft.AspNetCore.Http.Validation.ValidationOptions

src/Http/Http.Abstractions/src/Validation/ValidateContext.cs

@@ -3,6 +3,8 @@
 
 using System.ComponentModel.DataAnnotations;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text.Json;
 
 namespace Microsoft.AspNetCore.Http.Validation;
 
@@ -59,42 +61,195 @@ public sealed class ValidateContext
     /// This is used to prevent stack overflows from circular references.
     /// </summary>
     public int CurrentDepth { get; set; }
+
+    /// <summary>
+    /// Gets or sets the JSON serializer options to use for property name formatting.
+    /// When available, property names in validation errors will be formatted according to the
+    /// PropertyNamingPolicy and JsonPropertyName attributes.
+    /// </summary>
+    public JsonSerializerOptions? SerializerOptions { get; set; }
 
-    internal void AddValidationError(string key, string[] error)
+    internal void AddValidationError(string key, string[] errors)
     {
         ValidationErrors ??= [];
 
-        ValidationErrors[key] = error;
+        var formattedKey = FormatKey(key);
+        var formattedErrors = errors.Select(FormatErrorMessage).ToArray();
+        ValidationErrors[formattedKey] = formattedErrors;
     }
 
     internal void AddOrExtendValidationErrors(string key, string[] errors)
     {
         ValidationErrors ??= [];
 
-        if (ValidationErrors.TryGetValue(key, out var existingErrors))
+        var formattedKey = FormatKey(key);
+        var formattedErrors = errors.Select(FormatErrorMessage).ToArray();
+
+        if (ValidationErrors.TryGetValue(formattedKey, out var existingErrors))
         {
-            var newErrors = new string[existingErrors.Length + errors.Length];
+            var newErrors = new string[existingErrors.Length + formattedErrors.Length];
             existingErrors.CopyTo(newErrors, 0);
-            errors.CopyTo(newErrors, existingErrors.Length);
-            ValidationErrors[key] = newErrors;
+            formattedErrors.CopyTo(newErrors, existingErrors.Length);
+            ValidationErrors[formattedKey] = newErrors;
         }
         else
         {
-            ValidationErrors[key] = errors;
+            ValidationErrors[formattedKey] = formattedErrors;
         }
     }
 
     internal void AddOrExtendValidationError(string key, string error)
     {
         ValidationErrors ??= [];
 
-        if (ValidationErrors.TryGetValue(key, out var existingErrors) && !existingErrors.Contains(error))
+        var formattedKey = FormatKey(key);
+        var formattedError = FormatErrorMessage(error);
+
+        if (ValidationErrors.TryGetValue(formattedKey, out var existingErrors) && !existingErrors.Contains(formattedError))
         {
-            ValidationErrors[key] = [.. existingErrors, error];
+            ValidationErrors[formattedKey] = [.. existingErrors, formattedError];
         }
         else
         {
-            ValidationErrors[key] = [error];
+            ValidationErrors[formattedKey] = [formattedError];
+        }
+    }
+
+    private string FormatKey(string key)
+    {
+        if (string.IsNullOrEmpty(key) || SerializerOptions?.PropertyNamingPolicy is null)
+        {
+            return key;
+        }
+
+        // If the key contains a path (e.g., "Address.Street" or "Items[0].Name"), 
+        // apply the naming policy to each part of the path
+        if (key.Contains('.') || key.Contains('['))
+        {
+            return FormatComplexKey(key);
+        }
+
+        // Apply the naming policy directly
+        return SerializerOptions.PropertyNamingPolicy.ConvertName(key);
+    }
+
+    private string FormatComplexKey(string key)
+    {
+        // Use a more direct approach for complex keys with dots and array indices
+        var result = new System.Text.StringBuilder();
+        int lastIndex = 0;
+        int i = 0;
+        bool inBracket = false;
+        var propertyNamingPolicy = SerializerOptions?.PropertyNamingPolicy;
+
+        while (i < key.Length)
+        {
+            char c = key[i];
+
+            if (c == '[')
+            {
+                // Format the segment before the bracket
+                if (i > lastIndex)
+                {
+                    string segment = key.Substring(lastIndex, i - lastIndex);
+                    string formattedSegment = propertyNamingPolicy is not null 
+                        ? propertyNamingPolicy.ConvertName(segment) 
+                        : segment;
+                    result.Append(formattedSegment);
+                }
+
+                // Start collecting the bracket part
+                inBracket = true;
+                result.Append(c);
+                lastIndex = i + 1;
+            }
+            else if (c == ']')
+            {
+                // Add the content inside the bracket as-is
+                if (i > lastIndex)
+                {
+                    string segment = key.Substring(lastIndex, i - lastIndex);
+                    result.Append(segment);
+                }
+                result.Append(c);
+                inBracket = false;
+                lastIndex = i + 1;
+            }
+            else if (c == '.' && !inBracket)
+            {
+                // Format the segment before the dot
+                if (i > lastIndex)
+                {
+                    string segment = key.Substring(lastIndex, i - lastIndex);
+                    string formattedSegment = propertyNamingPolicy is not null 
+                        ? propertyNamingPolicy.ConvertName(segment) 
+                        : segment;
+                    result.Append(formattedSegment);
+                }
+                result.Append(c);
+                lastIndex = i + 1;
+            }
+
+            i++;
+        }
+
+        // Format the last segment if there is one
+        if (lastIndex < key.Length)
+        {
+            string segment = key.Substring(lastIndex);
+            if (!inBracket && propertyNamingPolicy is not null)
+            {
+                segment = propertyNamingPolicy.ConvertName(segment);
+            }
+            result.Append(segment);
+        }
+
+        return result.ToString();
+    }
+
+    // Format validation error messages to use the same property naming policy as the keys
+    private string FormatErrorMessage(string errorMessage)
+    {
+        if (SerializerOptions?.PropertyNamingPolicy is null)
+        {
+            return errorMessage;
+        }
+
+        // Common pattern: "The {PropertyName} field is required."
+        const string pattern = "The ";
+        const string fieldPattern = " field ";
+
+        int startIndex = errorMessage.IndexOf(pattern, StringComparison.Ordinal);
+        if (startIndex != 0)
+        {
+            return errorMessage; // Does not start with "The "
+        }
+
+        int endIndex = errorMessage.IndexOf(fieldPattern, pattern.Length, StringComparison.Ordinal);
+        if (endIndex <= pattern.Length)
+        {
+            return errorMessage; // Does not contain " field " or it's too early
+        }
+
+        // Extract the property name between "The " and " field "
+        // Use ReadOnlySpan<char> for better performance
+        ReadOnlySpan<char> messageSpan = errorMessage.AsSpan();
+        ReadOnlySpan<char> propertyNameSpan = messageSpan.Slice(pattern.Length, endIndex - pattern.Length);
+        string propertyName = propertyNameSpan.ToString();
+
+        if (string.IsNullOrWhiteSpace(propertyName))
+        {
+            return errorMessage;
         }
+
+        // Format the property name with the naming policy
+        string formattedPropertyName = SerializerOptions.PropertyNamingPolicy.ConvertName(propertyName);
+
+        // Construct the new error message by combining parts
+        return string.Concat(
+            pattern, 
+            formattedPropertyName, 
+            messageSpan.Slice(endIndex).ToString()
+        );
     }
 }