Respect JsonSerializerOptions casing for property names in validation errors

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

@@ -23,6 +23,8 @@ Microsoft.AspNetCore.Http.Validation.ValidateContext.CurrentDepth.get -> int
 Microsoft.AspNetCore.Http.Validation.ValidateContext.CurrentDepth.set -> void
 Microsoft.AspNetCore.Http.Validation.ValidateContext.CurrentValidationPath.get -> string!
 Microsoft.AspNetCore.Http.Validation.ValidateContext.CurrentValidationPath.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.ValidateContext() -> void
 Microsoft.AspNetCore.Http.Validation.ValidateContext.ValidationContext.get -> System.ComponentModel.DataAnnotations.ValidationContext!
 Microsoft.AspNetCore.Http.Validation.ValidateContext.ValidationContext.set -> void

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

@@ -3,6 +3,7 @@
 
 using System.ComponentModel.DataAnnotations;
 using System.Diagnostics.CodeAnalysis;
+using System.Text.Json;
 
 namespace Microsoft.AspNetCore.Http.Validation;
 
@@ -60,41 +61,139 @@ public sealed class ValidateContext
     /// </summary>
     public int CurrentDepth { get; set; }
 
+    /// <summary>
+    /// Gets or sets the JSON serializer options to use for property name formatting.
+    /// When set, 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)
     {
         ValidationErrors ??= [];
 
-        ValidationErrors[key] = error;
+        var formattedKey = FormatKey(key);
+        ValidationErrors[formattedKey] = error;
     }
 
     internal void AddOrExtendValidationErrors(string key, string[] errors)
     {
         ValidationErrors ??= [];
 
-        if (ValidationErrors.TryGetValue(key, out var existingErrors))
+        var formattedKey = FormatKey(key);
+        if (ValidationErrors.TryGetValue(formattedKey, out var existingErrors))
         {
             var newErrors = new string[existingErrors.Length + errors.Length];
             existingErrors.CopyTo(newErrors, 0);
             errors.CopyTo(newErrors, existingErrors.Length);
-            ValidationErrors[key] = newErrors;
+            ValidationErrors[formattedKey] = newErrors;
         }
         else
         {
-            ValidationErrors[key] = errors;
+            ValidationErrors[formattedKey] = errors;
         }
     }
 
     internal void AddOrExtendValidationError(string key, string error)
     {
         ValidationErrors ??= [];
 
-        if (ValidationErrors.TryGetValue(key, out var existingErrors) && !existingErrors.Contains(error))
+        var formattedKey = FormatKey(key);
+        if (ValidationErrors.TryGetValue(formattedKey, out var existingErrors) && !existingErrors.Contains(error))
         {
-            ValidationErrors[key] = [.. existingErrors, error];
+            ValidationErrors[formattedKey] = [.. existingErrors, error];
         }
         else
         {
-            ValidationErrors[key] = [error];
+            ValidationErrors[formattedKey] = [error];
+        }
+    }
+
+    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);
         }
+
+        // For JsonPropertyName attribute support, we'd need property info
+        // but for basic usage, 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;
+
+        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 = SerializerOptions!.PropertyNamingPolicy!.ConvertName(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 = SerializerOptions!.PropertyNamingPolicy!.ConvertName(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)
+            {
+                segment = SerializerOptions!.PropertyNamingPolicy!.ConvertName(segment);
+            }
+            result.Append(segment);
+        }
+
+        return result.ToString();
     }
 }