Fix ValidatableTypeInfo to skip IValidatableObject validation when property validation fails

Co-authored-by: captainsafia <[email protected]>

Author: Copilot

src/Validation/src/PublicAPI.Unshipped.txt

@@ -48,4 +48,6 @@ abstract Microsoft.Extensions.Validation.ValidatablePropertyInfo.GetValidationAt
 static Microsoft.Extensions.DependencyInjection.ValidationServiceCollectionExtensions.AddValidation(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, System.Action<Microsoft.Extensions.Validation.ValidationOptions!>? configureOptions = null) -> Microsoft.Extensions.DependencyInjection.IServiceCollection!
 virtual Microsoft.Extensions.Validation.ValidatableParameterInfo.ValidateAsync(object? value, Microsoft.Extensions.Validation.ValidateContext! context, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
 virtual Microsoft.Extensions.Validation.ValidatablePropertyInfo.ValidateAsync(object? value, Microsoft.Extensions.Validation.ValidateContext! context, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+virtual Microsoft.Extensions.Validation.ValidatablePropertyInfo.ValidateComplexObjectsAsync(object? value, Microsoft.Extensions.Validation.ValidateContext! context, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!
+virtual Microsoft.Extensions.Validation.ValidatablePropertyInfo.ValidatePropertyAttributesAsync(object? value, Microsoft.Extensions.Validation.ValidateContext! context, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task<bool>!
 virtual Microsoft.Extensions.Validation.ValidatableTypeInfo.ValidateAsync(object? value, Microsoft.Extensions.Validation.ValidateContext! context, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task!

src/Validation/src/ValidatablePropertyInfo.cs

@@ -59,6 +59,16 @@ protected ValidatablePropertyInfo(
 
     /// <inheritdoc />
     public virtual async Task ValidateAsync(object? value, ValidateContext context, CancellationToken cancellationToken)
+    {
+        await ValidatePropertyAttributesAsync(value, context, cancellationToken);
+        await ValidateComplexObjectsAsync(value, context, cancellationToken);
+    }
+
+    /// <summary>
+    /// Validates only the property attributes (Required, Range, etc.) without validating complex objects.
+    /// Returns true if there were validation errors.
+    /// </summary>
+    public virtual Task<bool> ValidatePropertyAttributesAsync(object? value, ValidateContext context, CancellationToken cancellationToken)
     {
         var property = DeclaringType.GetProperty(Name) ?? throw new InvalidOperationException($"Property '{Name}' not found on type '{DeclaringType.Name}'.");
         var propertyValue = property.GetValue(value);
@@ -78,6 +88,8 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
         context.ValidationContext.DisplayName = DisplayName;
         context.ValidationContext.MemberName = Name;
 
+        var hadValidationErrors = false;
+
         // Check required attribute first
         if (_requiredAttribute is not null || validationAttributes.TryGetRequiredAttribute(out _requiredAttribute))
         {
@@ -87,12 +99,49 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
             {
                 context.AddValidationError(Name, context.CurrentValidationPath, [result.ErrorMessage], value);
                 context.CurrentValidationPath = originalPrefix; // Restore prefix
-                return;
+                return Task.FromResult(true);
             }
         }
 
+        // Track errors before validating other attributes  
+        var errorCountBeforeOtherValidation = context.ValidationErrors?.Count ?? 0;
+
         // Validate any other attributes
-        ValidateValue(propertyValue, Name, context.CurrentValidationPath, validationAttributes, value);
+        ValidateValue(propertyValue, Name, context.CurrentValidationPath, validationAttributes, value, context);
+
+        // Check if other validation introduced errors
+        if ((context.ValidationErrors?.Count ?? 0) > errorCountBeforeOtherValidation)
+        {
+            hadValidationErrors = true;
+        }
+
+        // Restore prefix
+        context.CurrentValidationPath = originalPrefix;
+        
+        return Task.FromResult(hadValidationErrors);
+    }
+
+    /// <summary>
+    /// Validates complex objects (sub-types) for this property.
+    /// </summary>
+    public virtual async Task ValidateComplexObjectsAsync(object? value, ValidateContext context, CancellationToken cancellationToken)
+    {
+        var property = DeclaringType.GetProperty(Name) ?? throw new InvalidOperationException($"Property '{Name}' not found on type '{DeclaringType.Name}'.");
+        var propertyValue = property.GetValue(value);
+
+        // Calculate and save the current path
+        var originalPrefix = context.CurrentValidationPath;
+        if (string.IsNullOrEmpty(originalPrefix))
+        {
+            context.CurrentValidationPath = Name;
+        }
+        else
+        {
+            context.CurrentValidationPath = $"{originalPrefix}.{Name}";
+        }
+
+        context.ValidationContext.DisplayName = DisplayName;
+        context.ValidationContext.MemberName = Name;
 
         // Check if we've reached the maximum depth before validating complex properties
         if (context.CurrentDepth >= context.ValidationOptions.MaxDepth)
@@ -149,27 +198,27 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
             context.CurrentDepth--;
             context.CurrentValidationPath = originalPrefix;
         }
+    }
 
-        void ValidateValue(object? val, string name, string errorPrefix, ValidationAttribute[] validationAttributes, object? container)
+    private static void ValidateValue(object? val, string name, string errorPrefix, ValidationAttribute[] validationAttributes, object? container, ValidateContext context)
+    {
+        for (var i = 0; i < validationAttributes.Length; i++)
         {
-            for (var i = 0; i < validationAttributes.Length; i++)
+            var attribute = validationAttributes[i];
+            try
             {
-                var attribute = validationAttributes[i];
-                try
-                {
-                    var result = attribute.GetValidationResult(val, context.ValidationContext);
-                    if (result is not null && result != ValidationResult.Success && result.ErrorMessage is not null)
-                    {
-                        var key = errorPrefix.TrimStart('.');
-                        context.AddOrExtendValidationErrors(name, key, [result.ErrorMessage], container);
-                    }
-                }
-                catch (Exception ex)
+                var result = attribute.GetValidationResult(val, context.ValidationContext);
+                if (result is not null && result != ValidationResult.Success && result.ErrorMessage is not null)
                 {
                     var key = errorPrefix.TrimStart('.');
-                    context.AddOrExtendValidationErrors(name, key, [ex.Message], container);
+                    context.AddOrExtendValidationErrors(name, key, [result.ErrorMessage], container);
                 }
             }
+            catch (Exception ex)
+            {
+                var key = errorPrefix.TrimStart('.');
+                context.AddOrExtendValidationErrors(name, key, [ex.Message], container);
+            }
         }
     }
 }

src/Validation/src/ValidatableTypeInfo.cs

@@ -64,10 +64,23 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
         {
             var actualType = value.GetType();
 
-            // First validate members
+            // Track if there are any property-level validation errors from this type
+            var hasPropertyValidationErrors = false;
+
+            // First validate only property attributes for each member
+            for (var i = 0; i < _membersCount; i++)
+            {
+                if (await Members[i].ValidatePropertyAttributesAsync(value, context, cancellationToken))
+                {
+                    hasPropertyValidationErrors = true;
+                }
+                context.CurrentValidationPath = originalPrefix;
+            }
+
+            // Then validate complex objects for each member
             for (var i = 0; i < _membersCount; i++)
             {
-                await Members[i].ValidateAsync(value, context, cancellationToken);
+                await Members[i].ValidateComplexObjectsAsync(value, context, cancellationToken);
                 context.CurrentValidationPath = originalPrefix;
             }
 
@@ -86,8 +99,8 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
                 }
             }
 
-            // Finally validate IValidatableObject if implemented
-            if (Type.ImplementsInterface(typeof(IValidatableObject)) && value is IValidatableObject validatable)
+            // Finally validate IValidatableObject if implemented, but only if there are no property validation errors
+            if (Type.ImplementsInterface(typeof(IValidatableObject)) && value is IValidatableObject validatable && !hasPropertyValidationErrors)
             {
                 // Important: Set the DisplayName to the type name for top-level validations
                 // and restore the original validation context properties

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

@@ -125,6 +125,8 @@ async Task ValidateMethodCalledIfPropertyValidationsFail()
                 await endpoint.RequestDelegate(httpContext);
 
                 var problemDetails = await AssertBadRequest(httpContext);
+                // With the fix, IValidatableObject validation should not run when property validation fails
+                // So we should only get the property validation errors, not the IValidatableObject error for Value1
                 Assert.Collection(problemDetails.Errors,
                     error =>
                     {
@@ -141,11 +143,6 @@ async Task ValidateMethodCalledIfPropertyValidationsFail()
                     {
                         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("The field Value1 must be between 10 and 100.", error.Value.Single());
                     });
             }