Respect JsonSerializerOptions in validation errors

Author: captainsafia

src/Validation/src/Microsoft.Extensions.Validation.csproj

@@ -12,6 +12,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <Reference Include="Microsoft.AspNetCore.Http.Extensions" PrivateAssets="all" />
     <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
     <Reference Include="Microsoft.Extensions.Options" />
   </ItemGroup>

src/Validation/src/ValidatablePropertyInfo.cs

@@ -3,6 +3,9 @@
 
 using System.ComponentModel.DataAnnotations;
 using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
 
 namespace Microsoft.Extensions.Validation;
 
@@ -13,12 +16,13 @@ namespace Microsoft.Extensions.Validation;
 public abstract class ValidatablePropertyInfo : IValidatableInfo
 {
     private RequiredAttribute? _requiredAttribute;
+    private readonly bool _hasDisplayAttribute;
 
     /// <summary>
     /// Creates a new instance of <see cref="ValidatablePropertyInfo"/>.
     /// </summary>
     protected ValidatablePropertyInfo(
-        [param: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)]
+        [param: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicConstructors)]
         Type declaringType,
         Type propertyType,
         string name,
@@ -28,12 +32,16 @@ protected ValidatablePropertyInfo(
         PropertyType = propertyType;
         Name = name;
         DisplayName = displayName;
+
+        // Cache the HasDisplayAttribute result to avoid repeated reflection calls
+        var property = DeclaringType.GetProperty(Name);
+        _hasDisplayAttribute = property is not null && HasDisplayAttribute(property);
     }
 
     /// <summary>
     /// Gets the member type.
     /// </summary>
-    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)]
+    [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicConstructors)]
     internal Type DeclaringType { get; }
 
     /// <summary>
@@ -64,19 +72,27 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
         var propertyValue = property.GetValue(value);
         var validationAttributes = GetValidationAttributes();
 
+        // Get JsonSerializerOptions from DI container
+        var namingPolicy = context.SerializerOptions?.PropertyNamingPolicy;
+
         // Calculate and save the current path
+        var memberName = GetJsonPropertyName(Name, property, namingPolicy);
         var originalPrefix = context.CurrentValidationPath;
         if (string.IsNullOrEmpty(originalPrefix))
         {
-            context.CurrentValidationPath = Name;
+            context.CurrentValidationPath = memberName;
         }
         else
         {
-            context.CurrentValidationPath = $"{originalPrefix}.{Name}";
+            context.CurrentValidationPath = $"{originalPrefix}.{memberName}";
         }
 
-        context.ValidationContext.DisplayName = DisplayName;
-        context.ValidationContext.MemberName = Name;
+        // Format the display name and member name according to JsonPropertyName attribute first, then naming policy
+        // If the property has a [Display] attribute (either on property or record parameter), use DisplayName directly without formatting
+        context.ValidationContext.DisplayName = _hasDisplayAttribute
+            ? DisplayName
+            : GetJsonPropertyName(DisplayName, property, namingPolicy);
+        context.ValidationContext.MemberName = memberName;
 
         // Check required attribute first
         if (_requiredAttribute is not null || validationAttributes.TryGetRequiredAttribute(out _requiredAttribute))
@@ -170,4 +186,61 @@ void ValidateValue(object? val, string errorPrefix, ValidationAttribute[] valida
             }
         }
     }
+
+    /// <summary>
+    /// Gets the effective member name for JSON serialization, considering <see cref="JsonPropertyNameAttribute"/> and naming policy.
+    /// </summary>
+    /// <param name="targetValue">The target value to get the name for.</param>
+    /// <param name="property">The property info to get the name for.</param>
+    /// <param name="namingPolicy">The JSON naming policy to apply if no <see cref="JsonPropertyNameAttribute"/> is present.</param>
+    /// <returns>The effective property name for JSON serialization.</returns>
+    private static string GetJsonPropertyName(string targetValue, PropertyInfo property, JsonNamingPolicy? namingPolicy)
+    {
+        var jsonPropertyName = property.GetCustomAttribute<JsonPropertyNameAttribute>()?.Name;
+
+        if (jsonPropertyName is not null)
+        {
+            return jsonPropertyName;
+        }
+
+        if (namingPolicy is not null)
+        {
+            return namingPolicy.ConvertName(targetValue);
+        }
+
+        return targetValue;
+    }
+
+    /// <summary>
+    /// Determines whether the property has a <see cref="DisplayAttribute"/>, either directly on the property
+    /// or on the corresponding constructor parameter if the declaring type is a record.
+    /// </summary>
+    /// <param name="property">The property to check.</param>
+    /// <returns>True if the property has a <see cref="DisplayAttribute"/> , false otherwise.</returns>
+    private bool HasDisplayAttribute(PropertyInfo property)
+    {
+        // Check if the property itself has the DisplayAttribute with a valid Name
+        if (property.GetCustomAttribute<DisplayAttribute>() is { Name: not null })
+        {
+            return true;
+        }
+
+        // Look for a constructor parameter matching the property name (case-insensitive)
+        // to account for the record scenario
+        foreach (var constructor in DeclaringType.GetConstructors())
+        {
+            foreach (var parameter in constructor.GetParameters())
+            {
+                if (string.Equals(parameter.Name, property.Name, StringComparison.OrdinalIgnoreCase))
+                {
+                    if (parameter.GetCustomAttribute<DisplayAttribute>() is { Name: not null })
+                    {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
 }

src/Validation/src/ValidatableTypeInfo.cs

@@ -106,9 +106,13 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
                         // Create a validation error for each member name that is provided
                         foreach (var memberName in validationResult.MemberNames)
                         {
+                            // Format the member name using JsonSerializerOptions naming policy if available
+                            // Note: we don't respect [JsonPropertyName] here because we have no context of the property being validated.
+                            var formattedMemberName = context.SerializerOptions?.PropertyNamingPolicy?.ConvertName(memberName) ?? memberName;
+
                             var key = string.IsNullOrEmpty(originalPrefix) ?
-                                memberName :
-                                $"{originalPrefix}.{memberName}";
+                                formattedMemberName :
+                                $"{originalPrefix}.{formattedMemberName}";
                             context.AddOrExtendValidationError(key, validationResult.ErrorMessage);
                         }
 

src/Validation/src/ValidateContext.cs

@@ -3,6 +3,10 @@
 
 using System.ComponentModel.DataAnnotations;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text.Json;
+using Microsoft.AspNetCore.Http.Json;
+using Microsoft.Extensions.Options;
 
 namespace Microsoft.Extensions.Validation;
 
@@ -60,6 +64,8 @@ public sealed class ValidateContext
     /// </summary>
     public int CurrentDepth { get; set; }
 
+    internal JsonSerializerOptions? SerializerOptions => ValidationContext.GetService(typeof(IOptions<JsonOptions>)) is IOptions<JsonOptions> options ? options.Value.SerializerOptions : null;
+
     internal void AddValidationError(string key, string[] error)
     {
         ValidationErrors ??= [];
@@ -90,7 +96,7 @@ internal void AddOrExtendValidationError(string key, string error)
 
         if (ValidationErrors.TryGetValue(key, out var existingErrors) && !existingErrors.Contains(error))
         {
-            ValidationErrors[key] = [.. existingErrors, error];
+            ValidationErrors[key] = [..existingErrors, error];
         }
         else
         {

src/Validation/test/Microsoft.Extensions.Validation.GeneratorTests/ValidationsGenerator.ComplexType.cs

@@ -126,8 +126,8 @@ async Task InvalidIntegerWithRangeProducesError(Endpoint endpoint)
                 var problemDetails = await AssertBadRequest(context);
                 Assert.Collection(problemDetails.Errors, kvp =>
                 {
-                    Assert.Equal("IntegerWithRange", kvp.Key);
-                    Assert.Equal("The field IntegerWithRange must be between 10 and 100.", kvp.Value.Single());
+                    Assert.Equal("integerWithRange", kvp.Key);
+                    Assert.Equal("The field integerWithRange must be between 10 and 100.", kvp.Value.Single());
                 });
             }
 
@@ -145,7 +145,7 @@ async Task InvalidIntegerWithRangeAndDisplayNameProducesError(Endpoint endpoint)
                 var problemDetails = await AssertBadRequest(context);
                 Assert.Collection(problemDetails.Errors, kvp =>
                 {
-                    Assert.Equal("IntegerWithRangeAndDisplayName", kvp.Key);
+                    Assert.Equal("integerWithRangeAndDisplayName", kvp.Key);
                     Assert.Equal("The field Valid identifier must be between 10 and 100.", kvp.Value.Single());
                 });
             }
@@ -164,8 +164,8 @@ async Task MissingRequiredSubtypePropertyProducesError(Endpoint endpoint)
                 var problemDetails = await AssertBadRequest(context);
                 Assert.Collection(problemDetails.Errors, kvp =>
                 {
-                    Assert.Equal("PropertyWithMemberAttributes", kvp.Key);
-                    Assert.Equal("The PropertyWithMemberAttributes field is required.", kvp.Value.Single());
+                    Assert.Equal("propertyWithMemberAttributes", kvp.Key);
+                    Assert.Equal("The propertyWithMemberAttributes field is required.", kvp.Value.Single());
                 });
             }
 
@@ -187,13 +187,13 @@ async Task InvalidRequiredSubtypePropertyProducesError(Endpoint endpoint)
                 Assert.Collection(problemDetails.Errors,
                 kvp =>
                 {
-                    Assert.Equal("PropertyWithMemberAttributes.RequiredProperty", kvp.Key);
-                    Assert.Equal("The RequiredProperty field is required.", kvp.Value.Single());
+                    Assert.Equal("propertyWithMemberAttributes.requiredProperty", kvp.Key);
+                    Assert.Equal("The requiredProperty field is required.", kvp.Value.Single());
                 },
                 kvp =>
                 {
-                    Assert.Equal("PropertyWithMemberAttributes.StringWithLength", kvp.Key);
-                    Assert.Equal("The field StringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
+                    Assert.Equal("propertyWithMemberAttributes.stringWithLength", kvp.Key);
+                    Assert.Equal("The field stringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
                 });
             }
 
@@ -216,18 +216,18 @@ async Task InvalidSubTypeWithInheritancePropertyProducesError(Endpoint endpoint)
                 Assert.Collection(problemDetails.Errors,
                 kvp =>
                 {
-                    Assert.Equal("PropertyWithInheritance.EmailString", kvp.Key);
-                    Assert.Equal("The EmailString field is not a valid e-mail address.", kvp.Value.Single());
+                    Assert.Equal("propertyWithInheritance.emailString", kvp.Key);
+                    Assert.Equal("The emailString field is not a valid e-mail address.", kvp.Value.Single());
                 },
                 kvp =>
                 {
-                    Assert.Equal("PropertyWithInheritance.RequiredProperty", kvp.Key);
-                    Assert.Equal("The RequiredProperty field is required.", kvp.Value.Single());
+                    Assert.Equal("propertyWithInheritance.requiredProperty", kvp.Key);
+                    Assert.Equal("The requiredProperty field is required.", kvp.Value.Single());
                 },
                 kvp =>
                 {
-                    Assert.Equal("PropertyWithInheritance.StringWithLength", kvp.Key);
-                    Assert.Equal("The field StringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
+                    Assert.Equal("propertyWithInheritance.stringWithLength", kvp.Key);
+                    Assert.Equal("The field stringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
                 });
             }
 
@@ -259,18 +259,18 @@ async Task InvalidListOfSubTypesProducesError(Endpoint endpoint)
                 Assert.Collection(problemDetails.Errors,
                 kvp =>
                 {
-                    Assert.Equal("ListOfSubTypes[0].RequiredProperty", kvp.Key);
-                    Assert.Equal("The RequiredProperty field is required.", kvp.Value.Single());
+                    Assert.Equal("listOfSubTypes[0].requiredProperty", kvp.Key);
+                    Assert.Equal("The requiredProperty field is required.", kvp.Value.Single());
                 },
                 kvp =>
                 {
-                    Assert.Equal("ListOfSubTypes[0].StringWithLength", kvp.Key);
-                    Assert.Equal("The field StringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
+                    Assert.Equal("listOfSubTypes[0].stringWithLength", kvp.Key);
+                    Assert.Equal("The field stringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
                 },
                 kvp =>
                 {
-                    Assert.Equal("ListOfSubTypes[1].StringWithLength", kvp.Key);
-                    Assert.Equal("The field StringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
+                    Assert.Equal("listOfSubTypes[1].stringWithLength", kvp.Key);
+                    Assert.Equal("The field stringWithLength must be a string with a maximum length of 10.", kvp.Value.Single());
                 });
             }
 
@@ -288,7 +288,7 @@ async Task InvalidPropertyWithDerivedValidationAttributeProducesError(Endpoint e
                 var problemDetails = await AssertBadRequest(context);
                 Assert.Collection(problemDetails.Errors, kvp =>
                 {
-                    Assert.Equal("IntegerWithDerivedValidationAttribute", kvp.Key);
+                    Assert.Equal("integerWithDerivedValidationAttribute", kvp.Key);
                     Assert.Equal("Value must be an even number", kvp.Value.Single());
                 });
             }
@@ -297,7 +297,7 @@ async Task InvalidPropertyWithMultipleAttributesProducesError(Endpoint endpoint)
             {
                 var payload = """
                 {
-                    "PropertyWithMultipleAttributes": 5
+                    "propertyWithMultipleAttributes": 5
                 }
                 """;
                 var context = CreateHttpContextWithPayload(payload, serviceProvider);
@@ -307,15 +307,15 @@ async Task InvalidPropertyWithMultipleAttributesProducesError(Endpoint endpoint)
                 var problemDetails = await AssertBadRequest(context);
                 Assert.Collection(problemDetails.Errors, kvp =>
                 {
-                    Assert.Equal("PropertyWithMultipleAttributes", kvp.Key);
+                    Assert.Equal("propertyWithMultipleAttributes", kvp.Key);
                     Assert.Collection(kvp.Value,
                     error =>
                     {
-                        Assert.Equal("The field PropertyWithMultipleAttributes is invalid.", error);
+                        Assert.Equal("The field propertyWithMultipleAttributes is invalid.", error);
                     },
                     error =>
                     {
-                        Assert.Equal("The field PropertyWithMultipleAttributes must be between 10 and 100.", error);
+                        Assert.Equal("The field propertyWithMultipleAttributes must be between 10 and 100.", error);
                     });
                 });
             }
@@ -335,7 +335,7 @@ async Task InvalidPropertyWithCustomValidationProducesError(Endpoint endpoint)
                 var problemDetails = await AssertBadRequest(context);
                 Assert.Collection(problemDetails.Errors, kvp =>
                 {
-                    Assert.Equal("IntegerWithCustomValidation", kvp.Key);
+                    Assert.Equal("integerWithCustomValidation", kvp.Key);
                     var error = Assert.Single(kvp.Value);
                     Assert.Equal("Can't use the same number value in two properties on the same class.", error);
                 });

src/Validation/test/Microsoft.Extensions.Validation.GeneratorTests/ValidationsGenerator.IValidatableObject.cs

@@ -128,23 +128,23 @@ async Task ValidateMethodCalledIfPropertyValidationsFail()
                 Assert.Collection(problemDetails.Errors,
                     error =>
                     {
-                        Assert.Equal("Value2", error.Key);
+                        Assert.Equal("value2", error.Key);
                         Assert.Collection(error.Value,
-                            msg => Assert.Equal("The Value2 field is required.", msg));
+                            msg => Assert.Equal("The value2 field is required.", msg));
                     },
                     error =>
                     {
-                        Assert.Equal("SubType.RequiredProperty", error.Key);
-                        Assert.Equal("The RequiredProperty field is required.", error.Value.Single());
+                        Assert.Equal("subType.requiredProperty", error.Key);
+                        Assert.Equal("The requiredProperty field is required.", error.Value.Single());
                     },
                     error =>
                     {
-                        Assert.Equal("SubType.Value3", error.Key);
+                        Assert.Equal("subType.value3", error.Key);
                         Assert.Equal("The field ValidatableSubType must be 'some-value'.", error.Value.Single());
                     },
                     error =>
                     {
-                        Assert.Equal("Value1", error.Key);
+                        Assert.Equal("value1", error.Key);
                         Assert.Equal("The field Value1 must be between 10 and 100.", error.Value.Single());
                     });
             }
@@ -169,12 +169,12 @@ async Task ValidateForSubtypeInvokedFirst()
                 Assert.Collection(problemDetails.Errors,
                     error =>
                     {
-                        Assert.Equal("SubType.Value3", error.Key);
+                        Assert.Equal("subType.value3", error.Key);
                         Assert.Equal("The field ValidatableSubType must be 'some-value'.", error.Value.Single());
                     },
                     error =>
                     {
-                        Assert.Equal("Value1", error.Key);
+                        Assert.Equal("value1", error.Key);
                         Assert.Equal("The field Value1 must be between 10 and 100.", error.Value.Single());
                     });
             }
@@ -199,7 +199,7 @@ async Task ValidateForTopLevelInvoked()
                 Assert.Collection(problemDetails.Errors,
                     error =>
                     {
-                        Assert.Equal("Value1", error.Key);
+                        Assert.Equal("value1", error.Key);
                         Assert.Equal("The field Value1 must be between 10 and 100.", error.Value.Single());
                     });
             }