Recursively validating a complex model within a custom model binder

Question

Below is the code for a simple JsonModelBinder I created for an ASP.NET Core Mvc app. Is there a simple way to recursively validate the model, its properties and the properties of its properties and so on?

JsonModelBinder

public class JsonModelBinder : IModelBinder
{
    static readonly JsonSerializerSettings settings = new JsonSerializerSettings
    {
        NullValueHandling = NullValueHandling.Ignore,
        ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
    };

    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        try
        {
            var json = bindingContext.ValueProvider.GetValue(bindingContext.ModelName).Values;
            if (json.Count > 0)
            {
                var model = JsonConvert.DeserializeObject(json, bindingContext.ModelType, settings);
                // TODO: Validate complex model
                bindingContext.Result = ModelBindingResult.Success(model);
            }
            else
            {
                bindingContext.Result = ModelBindingResult.Success(null);
            }
        }
        catch (JsonException ex)
        {
            bindingContext.ModelState.AddModelError(bindingContext.ModelName, ex.Message);
            bindingContext.Result = ModelBindingResult.Failed();
        }

        return Task.CompletedTask;
    }
}

Example model

public class Foo {
    [Required]
    public string Name { get; set; }
    public List<Bar> Bars { get; set; }
    public Baz Baz { get; set; }
}

public class Bar {
    [Required]
    public string Name { get; set; }
}

public class Baz {
    [Required]
    public string Name { get; set; }
}

Controller action

public async Task<IActionResult> Edit(Guid id, [Required, ModelBinder(typeof(JsonModelBinder))] Foo foo) {
    if (ModelState.IsValid) {
        // Do stuff
    }
    else {
        return View(foo);
    }
}

Would it not be easier to create a custom validation Attribute? — Himanshu Pant, Jul 07 '19 at 13:12
Does this answer your question? [DataAnnotations: Recursively validating an entire object graph](https://stackoverflow.com/questions/7663501/dataannotations-recursively-validating-an-entire-object-graph) — Péter Szilvási, Mar 26 '22 at 12:01

score 0 · Answer 1 · answered Jul 07 '19 at 15:49

I created the following recursive data annotations validator, and used it like below. Based on some feedback I received, it appears that there is nothing like this built into .NET Core at this time.

Recursive data annotations validator:

public static class RecursiveValidator
{
    /// <summary>
    /// Recursively validates <paramref name="instance"/>.
    /// </summary>
    /// <param name="instance"></param>
    /// <param name="prefix"></param>
    /// <param name="validationContext"></param>
    /// <param name="results"></param>
    /// <param name="validateAllProperties"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentNullException"><paramref name="instance"/> is null</exception>
    public static bool TryValidateObject(object instance, IServiceProvider serviceProvider, IDictionary<object, object> items, ICollection<ValidationResult> results, bool validateAllProperties, string prefix)
    {
        if (instance is null)
        {
            throw new ArgumentNullException(nameof(instance));
        }

        var tempResults = new List<ValidationResult>();

        ValidationContext validationContext = new ValidationContext(instance, serviceProvider, items);
        var isValid = Validator.TryValidateObject(instance, validationContext, tempResults, validateAllProperties: validateAllProperties);

        foreach (var item in tempResults)
        {
            IEnumerable<string> memberNames = item.MemberNames.Select(name => (!string.IsNullOrEmpty(prefix) ? prefix + "." : "") + name);
            results.Add(new ValidationResult(item.ErrorMessage, memberNames));
        }

        foreach (var prop in instance.GetType().GetProperties())
        {
            if (prop.GetSetMethod() == null)
            {
                continue;
            }
            else if (prop.PropertyType.IsClass && prop.PropertyType != typeof(string))
            {
                var value = prop.GetValue(instance);
                if (value == null)
                {
                    continue;
                }
                else if (value is IEnumerable<object> list)
                {
                    var memberPrefix = (!string.IsNullOrEmpty(prefix) ? prefix + "." : "") + prop.Name;
                    int i = 0;
                    foreach (var item in list)
                    {
                        if (!TryValidateObject(item, serviceProvider, items, results, validateAllProperties: validateAllProperties, prefix: $"{memberPrefix}[{i}]"))
                        {
                            isValid = false;
                        }
                        i++;
                    }
                }
                else
                {
                    var memberPrefix = (!string.IsNullOrEmpty(prefix) ? prefix + "." : "") + prop.Name;
                    if (!TryValidateObject(value, serviceProvider, items, results, validateAllProperties: validateAllProperties, prefix: memberPrefix))
                    {
                        isValid = false;
                    }
                }
            }
        }

        return isValid;
    }
}

Example of using it to add model state errors to the bindingContext:

var validationResults = new List<ValidationResult>();
if (!RecursiveValidator.TryValidateObject(model, bindingContext.HttpContext.RequestServices, null, validationResults, validateAllProperties: true, prefix: bindingContext.ModelName))
{
    foreach (var result in validationResults)
    {
        foreach (var member in result.MemberNames)
        {
            bindingContext.ModelState.AddModelError(member, result.ErrorMessage);
        }
    }
}

Recursively validating a complex model within a custom model binder

1 Answers1