Рекурсивная проверка сложной модели в привязке пользовательской модели

Question

Ниже приведен код для простого JsonModelBinder, который я создал для приложения ASP.NET Core Mvc.Есть ли простой способ рекурсивной проверки model, его свойств и свойств его свойств и т. Д.?

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;
    }
}

Пример модели

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; }
}

Действие контроллера

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

Answer 1

Я создал следующий валидатор рекурсивных аннотаций данных и использовал его, как показано ниже.Судя по некоторым полученным мною отзывам, в настоящее время нет ничего подобного встроенному в .NET Core.

Средство проверки рекурсивных аннотаций данных:

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;
    }
}

Пример использования его для добавленияошибки состояния модели для привязки контекста:

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);
        }
    }
}