Add OnValidationError event to ValidateContext, use it to get field container instances in Blazor validation

oroztocil · javiercn · commit 826ab4c7eb9c · 2025-06-12T10:43:21.000+02:00
diff --git a/src/Components/Forms/src/EditContextDataAnnotationsExtensions.cs b/src/Components/Forms/src/EditContextDataAnnotationsExtensions.cs
@@ -173,6 +173,10 @@ private bool TryValidateTypeInfo(ValidationContext validationContext)
                 ValidationContext = validationContext,
             };
 
+            var containerMapping = new Dictionary<string, object?>();
+
+            validateContext.OnValidationError += (key, _, container) => containerMapping[key] = container;
+
             var validationTask = typeInfo.ValidateAsync(_editContext.Model, validateContext, CancellationToken.None);
 
             if (!validationTask.IsCompleted)
@@ -187,11 +191,16 @@ private bool TryValidateTypeInfo(ValidationContext validationContext)
 
             if (validationErrors is not null && validationErrors.Count > 0)
             {
-                foreach (var (fieldPath, messages) in validationErrors)
+                foreach (var (fieldKey, messages) in validationErrors)
                 {
-                    var dotSegments = fieldPath.Split('.');
-                    var fieldName = dotSegments[^1];
-                    var fieldContainer = GetFieldContainer(_editContext.Model, dotSegments[..^1]);
+                    // Reverse mapping based on storing references during validation
+                    var fieldContainer = containerMapping[fieldKey] ?? _editContext.Model;
+
+                    // Alternative: Reverse mapping based on object graph walk
+                    //var fieldContainer = GetFieldContainer(_editContext.Model, fieldKey);
+
+                    var lastDotIndex = fieldKey.LastIndexOf('.');
+                    var fieldName = lastDotIndex >= 0 ? fieldKey[(lastDotIndex + 1)..] : fieldKey;
 
                     _messages.Add(new FieldIdentifier(fieldContainer, fieldName), messages);
                 }
@@ -201,12 +210,13 @@ private bool TryValidateTypeInfo(ValidationContext validationContext)
         }
 #pragma warning restore ASP0029 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
 
-        // TODO(OR): Replace this with a more robust implementation or a different approach. Ideally, collect references during the validation process itself.
+        // TODO(OR): Replace this with a more robust implementation or a different approach. E.g. collect references during the validation process itself.
         [UnconditionalSuppressMessage("Trimming", "IL2075", Justification = "Model types are expected to be defined in assemblies that do not get trimmed.")]
-        private static object GetFieldContainer(object obj, string[] dotSegments)
+        private static object GetFieldContainer(object obj, string fieldKey)
         {
-            // The method does not check all possiblle null access and index bound errors as the path is constructed internally and assumed to be correct.
-            object currentObject = obj;
+            // The method does not check all possible null access and index bound errors as the path is constructed internally and assumed to be correct.
+            var dotSegments = fieldKey.Split('.')[..^1];
+            var currentObject = obj;
 
             for (int i = 0; i < dotSegments.Length; i++)
             {
diff --git a/src/Validation/src/ValidatableParameterInfo.cs b/src/Validation/src/ValidatableParameterInfo.cs
@@ -77,7 +77,7 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
             if (result is not null && result != ValidationResult.Success && result.ErrorMessage is not null)
             {
                 var key = string.IsNullOrEmpty(context.CurrentValidationPath) ? Name : $"{context.CurrentValidationPath}.{Name}";
-                context.AddValidationError(key, [result.ErrorMessage]);
+                context.AddValidationError(key, [result.ErrorMessage], null);
                 return;
             }
         }
@@ -92,13 +92,13 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
                 if (result is not null && result != ValidationResult.Success && result.ErrorMessage is not null)
                 {
                     var key = string.IsNullOrEmpty(context.CurrentValidationPath) ? Name : $"{context.CurrentValidationPath}.{Name}";
-                    context.AddOrExtendValidationErrors(key, [result.ErrorMessage]);
+                    context.AddOrExtendValidationErrors(key, [result.ErrorMessage], null);
                 }
             }
             catch (Exception ex)
             {
                 var key = string.IsNullOrEmpty(context.CurrentValidationPath) ? Name : $"{context.CurrentValidationPath}.{Name}";
-                context.AddValidationError(key, [ex.Message]);
+                context.AddValidationError(key, [ex.Message], null);
             }
         }
 
diff --git a/src/Validation/src/ValidatablePropertyInfo.cs b/src/Validation/src/ValidatablePropertyInfo.cs
@@ -85,14 +85,14 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
 
             if (result is not null && result != ValidationResult.Success && result.ErrorMessage is not null)
             {
-                context.AddValidationError(context.CurrentValidationPath, [result.ErrorMessage]);
+                context.AddValidationError(context.CurrentValidationPath, [result.ErrorMessage], value);
                 context.CurrentValidationPath = originalPrefix; // Restore prefix
                 return;
             }
         }
 
         // Validate any other attributes
-        ValidateValue(propertyValue, context.CurrentValidationPath, validationAttributes);
+        ValidateValue(propertyValue, context.CurrentValidationPath, validationAttributes, value);
 
         // Check if we've reached the maximum depth before validating complex properties
         if (context.CurrentDepth >= context.ValidationOptions.MaxDepth)
@@ -150,7 +150,7 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
             context.CurrentValidationPath = originalPrefix;
         }
 
-        void ValidateValue(object? val, string errorPrefix, ValidationAttribute[] validationAttributes)
+        void ValidateValue(object? val, string errorPrefix, ValidationAttribute[] validationAttributes, object? container)
         {
             for (var i = 0; i < validationAttributes.Length; i++)
             {
@@ -160,12 +160,12 @@ void ValidateValue(object? val, string errorPrefix, ValidationAttribute[] valida
                     var result = attribute.GetValidationResult(val, context.ValidationContext);
                     if (result is not null && result != ValidationResult.Success && result.ErrorMessage is not null)
                     {
-                        context.AddOrExtendValidationErrors(errorPrefix.TrimStart('.'), [result.ErrorMessage]);
+                        context.AddOrExtendValidationErrors(errorPrefix.TrimStart('.'), [result.ErrorMessage], container);
                     }
                 }
                 catch (Exception ex)
                 {
-                    context.AddOrExtendValidationErrors(errorPrefix.TrimStart('.'), [ex.Message]);
+                    context.AddOrExtendValidationErrors(errorPrefix.TrimStart('.'), [ex.Message], container);
                 }
             }
         }
diff --git a/src/Validation/src/ValidatableTypeInfo.cs b/src/Validation/src/ValidatableTypeInfo.cs
@@ -109,13 +109,13 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,
                             var key = string.IsNullOrEmpty(originalPrefix) ?
                                 memberName :
                                 $"{originalPrefix}.{memberName}";
-                            context.AddOrExtendValidationError(key, validationResult.ErrorMessage);
+                            context.AddOrExtendValidationError(key, validationResult.ErrorMessage, value);
                         }
 
                         if (!validationResult.MemberNames.Any())
                         {
                             // If no member names are specified, then treat this as a top-level error
-                            context.AddOrExtendValidationError(string.Empty, validationResult.ErrorMessage);
+                            context.AddOrExtendValidationError(string.Empty, validationResult.ErrorMessage, value);
                         }
                     }
                 }
diff --git a/src/Validation/src/ValidateContext.cs b/src/Validation/src/ValidateContext.cs
@@ -60,14 +60,20 @@ public sealed class ValidateContext
     /// </summary>
     public int CurrentDepth { get; set; }
 
-    internal void AddValidationError(string key, string[] error)
+    /// <summary>
+    /// Optional event raised when a validation error is reported.
+    /// </summary>
+    public event Action<string, string[], object?>? OnValidationError;
+
+    internal void AddValidationError(string key, string[] error, object? container)
     {
         ValidationErrors ??= [];
 
         ValidationErrors[key] = error;
+        OnValidationError?.Invoke(key, error, container);
     }
 
-    internal void AddOrExtendValidationErrors(string key, string[] errors)
+    internal void AddOrExtendValidationErrors(string key, string[] errors, object? container)
     {
         ValidationErrors ??= [];
 
@@ -82,9 +88,11 @@ internal void AddOrExtendValidationErrors(string key, string[] errors)
         {
             ValidationErrors[key] = errors;
         }
+
+        OnValidationError?.Invoke(key, errors, container);
     }
 
-    internal void AddOrExtendValidationError(string key, string error)
+    internal void AddOrExtendValidationError(string key, string error, object? container)
     {
         ValidationErrors ??= [];
 
@@ -96,5 +104,7 @@ internal void AddOrExtendValidationError(string key, string error)
         {
             ValidationErrors[key] = [error];
         }
+
+        OnValidationError?.Invoke(key, [error], container);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,`
`77`	`77`	`if (result is not null && result != ValidationResult.Success && result.ErrorMessage is not null)`
`78`	`78`	`{`
`79`	`79`	`var key = string.IsNullOrEmpty(context.CurrentValidationPath) ? Name : $"{context.CurrentValidationPath}.{Name}";`
`80`		`- context.AddValidationError(key, [result.ErrorMessage]);`
	`80`	`+ context.AddValidationError(key, [result.ErrorMessage], null);`
`81`	`81`	`return;`
`82`	`82`	`}`
`83`	`83`	`}`
`@@ -92,13 +92,13 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,`
`92`	`92`	`if (result is not null && result != ValidationResult.Success && result.ErrorMessage is not null)`
`93`	`93`	`{`
`94`	`94`	`var key = string.IsNullOrEmpty(context.CurrentValidationPath) ? Name : $"{context.CurrentValidationPath}.{Name}";`
`95`		`- context.AddOrExtendValidationErrors(key, [result.ErrorMessage]);`
	`95`	`+ context.AddOrExtendValidationErrors(key, [result.ErrorMessage], null);`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`	`catch (Exception ex)`
`99`	`99`	`{`
`100`	`100`	`var key = string.IsNullOrEmpty(context.CurrentValidationPath) ? Name : $"{context.CurrentValidationPath}.{Name}";`
`101`		`- context.AddValidationError(key, [ex.Message]);`
	`101`	`+ context.AddValidationError(key, [ex.Message], null);`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
Original file line number	Diff line number	Diff line change
`@@ -85,14 +85,14 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,`
`85`	`85`
`86`	`86`	`if (result is not null && result != ValidationResult.Success && result.ErrorMessage is not null)`
`87`	`87`	`{`
`88`		`- context.AddValidationError(context.CurrentValidationPath, [result.ErrorMessage]);`
	`88`	`+ context.AddValidationError(context.CurrentValidationPath, [result.ErrorMessage], value);`
`89`	`89`	`context.CurrentValidationPath = originalPrefix; // Restore prefix`
`90`	`90`	`return;`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`// Validate any other attributes`
`95`		`- ValidateValue(propertyValue, context.CurrentValidationPath, validationAttributes);`
	`95`	`+ ValidateValue(propertyValue, context.CurrentValidationPath, validationAttributes, value);`
`96`	`96`
`97`	`97`	`// Check if we've reached the maximum depth before validating complex properties`
`98`	`98`	`if (context.CurrentDepth >= context.ValidationOptions.MaxDepth)`
`@@ -150,7 +150,7 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,`
`150`	`150`	`context.CurrentValidationPath = originalPrefix;`
`151`	`151`	`}`
`152`	`152`
`153`		`- void ValidateValue(object? val, string errorPrefix, ValidationAttribute[] validationAttributes)`
	`153`	`+ void ValidateValue(object? val, string errorPrefix, ValidationAttribute[] validationAttributes, object? container)`
`154`	`154`	`{`
`155`	`155`	`for (var i = 0; i < validationAttributes.Length; i++)`
`156`	`156`	`{`
`@@ -160,12 +160,12 @@ void ValidateValue(object? val, string errorPrefix, ValidationAttribute[] valida`
`160`	`160`	`var result = attribute.GetValidationResult(val, context.ValidationContext);`
`161`	`161`	`if (result is not null && result != ValidationResult.Success && result.ErrorMessage is not null)`
`162`	`162`	`{`
`163`		`- context.AddOrExtendValidationErrors(errorPrefix.TrimStart('.'), [result.ErrorMessage]);`
	`163`	`+ context.AddOrExtendValidationErrors(errorPrefix.TrimStart('.'), [result.ErrorMessage], container);`
`164`	`164`	`}`
`165`	`165`	`}`
`166`	`166`	`catch (Exception ex)`
`167`	`167`	`{`
`168`		`- context.AddOrExtendValidationErrors(errorPrefix.TrimStart('.'), [ex.Message]);`
	`168`	`+ context.AddOrExtendValidationErrors(errorPrefix.TrimStart('.'), [ex.Message], container);`
`169`	`169`	`}`
`170`	`170`	`}`
`171`	`171`	`}`
Original file line number	Diff line number	Diff line change
`@@ -109,13 +109,13 @@ public virtual async Task ValidateAsync(object? value, ValidateContext context,`
`109`	`109`	`var key = string.IsNullOrEmpty(originalPrefix) ?`
`110`	`110`	`memberName :`
`111`	`111`	`$"{originalPrefix}.{memberName}";`
`112`		`- context.AddOrExtendValidationError(key, validationResult.ErrorMessage);`
	`112`	`+ context.AddOrExtendValidationError(key, validationResult.ErrorMessage, value);`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`if (!validationResult.MemberNames.Any())`
`116`	`116`	`{`
`117`	`117`	`// If no member names are specified, then treat this as a top-level error`
`118`		`- context.AddOrExtendValidationError(string.Empty, validationResult.ErrorMessage);`
	`118`	`+ context.AddOrExtendValidationError(string.Empty, validationResult.ErrorMessage, value);`
`119`	`119`	`}`
`120`	`120`	`}`
`121`	`121`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,14 +60,20 @@ public sealed class ValidateContext`
`60`	`60`	`/// </summary>`
`61`	`61`	`public int CurrentDepth { get; set; }`
`62`	`62`
`63`		`- internal void AddValidationError(string key, string[] error)`
	`63`	`+ /// <summary>`
	`64`	`+ /// Optional event raised when a validation error is reported.`
	`65`	`+ /// </summary>`
	`66`	`+ public event Action<string, string[], object?>? OnValidationError;`
	`67`	`+`
	`68`	`+ internal void AddValidationError(string key, string[] error, object? container)`
`64`	`69`	`{`
`65`	`70`	`ValidationErrors ??= [];`
`66`	`71`
`67`	`72`	`ValidationErrors[key] = error;`
	`73`	`+ OnValidationError?.Invoke(key, error, container);`
`68`	`74`	`}`
`69`	`75`
`70`		`- internal void AddOrExtendValidationErrors(string key, string[] errors)`
	`76`	`+ internal void AddOrExtendValidationErrors(string key, string[] errors, object? container)`
`71`	`77`	`{`
`72`	`78`	`ValidationErrors ??= [];`
`73`	`79`
`@@ -82,9 +88,11 @@ internal void AddOrExtendValidationErrors(string key, string[] errors)`
`82`	`88`	`{`
`83`	`89`	`ValidationErrors[key] = errors;`
`84`	`90`	`}`
	`91`	`+`
	`92`	`+ OnValidationError?.Invoke(key, errors, container);`
`85`	`93`	`}`
`86`	`94`
`87`		`- internal void AddOrExtendValidationError(string key, string error)`
	`95`	`+ internal void AddOrExtendValidationError(string key, string error, object? container)`
`88`	`96`	`{`
`89`	`97`	`ValidationErrors ??= [];`
`90`	`98`
`@@ -96,5 +104,7 @@ internal void AddOrExtendValidationError(string key, string error)`
`96`	`104`	`{`
`97`	`105`	`ValidationErrors[key] = [error];`
`98`	`106`	`}`
	`107`	`+`
	`108`	`+ OnValidationError?.Invoke(key, [error], container);`
`99`	`109`	`}`
`100`	`110`	`}`