Jak korzystać z IValidatableObject?

Cytat z bloga Jeffa Handleya na temat walidacji obiektów i właściwości za pomocą walidatora :

Podczas walidacji obiektu, następujący proces jest stosowany w Walidator.ValidateObject:

1. Walidacja atrybutów na poziomie właściwości
2. Jeśli walidatory są nieprawidłowe, przerwij walidację zwracając awarie
3. sprawdzanie atrybutów na poziomie obiektu
4. jeśli walidatory są nieprawidłowe, przerwij walidację zwracając awarie
5. Jeśli na pulpicie framework i obiekt implementuje IValidatableObject, a następnie wywołać jego Validate method and return any failure(s)

Oznacza to, że to, co próbujesz zrobić, nie zadziała po wyjęciu z pudełka, ponieważ Walidacja zostanie przerwana w Kroku # 2. Możesz spróbować utworzyć atrybuty dziedziczące po wbudowanych i dokładnie sprawdzić obecność włączonej właściwości (poprzez interfejs) przed wykonując ich normalną walidację. Alternatywnie, możesz umieścić całą logikę walidacji encji w metodzie Validate.

Aby dodać kilka punktów:

Ponieważ podpis metody Validate() zwraca IEnumerable<>, że yield return może być używany do leniwego generowania wyników - jest to korzystne, jeśli niektóre kontrole walidacji są obciążone IO lub CPU.

public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
    if (this.Enable)
    {
        // ...
        if (this.Prop1 > this.Prop2)
        {
            yield return new ValidationResult("Prop1 must be larger than Prop2");
        }

Ponadto, jeśli używasz MVC ModelState, możesz przekonwertować błędy wyniku walidacji na wpisy ModelState w następujący sposób (może to być przydatne, jeśli wykonujesz walidację w segregatorze niestandardowego modelu ):

var resultsGroupedByMembers = validationResults
    .SelectMany(vr => vr.MemberNames
                        .Select(mn => new { MemberName = mn ?? "", 
                                            Error = vr.ErrorMessage }))
    .GroupBy(x => x.MemberName);

foreach (var member in resultsGroupedByMembers)
{
    ModelState.AddModelError(
        member.Key,
        string.Join(". ", member.Select(m => m.Error)));
}

Zaimplementowałem klasy abstrakcyjne ogólnego użycia dla walidacji

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace App.Abstractions
{
    [Serializable]
    abstract public class AEntity
    {
        public int Id { get; set; }

        public IEnumerable<ValidationResult> Validate()
        {
            var vResults = new List<ValidationResult>();

            var vc = new ValidationContext(
                instance: this,
                serviceProvider: null,
                items: null);

            var isValid = Validator.TryValidateObject(
                instance: vc.ObjectInstance,
                validationContext: vc,
                validationResults: vResults,
                validateAllProperties: true);

            /*
            if (true)
            {
                yield return new ValidationResult("Custom Validation","A Property Name string (optional)");
            }
            */

            if (!isValid)
            {
                foreach (var validationResult in vResults)
                {
                    yield return validationResult;
                }
            }

            yield break;
        }


    }
}

Problem z zaakceptowaną odpowiedzią polega na tym, że od wywołującego zależy, czy obiekt zostanie poprawnie zweryfikowany. Chciałbym albo usunąć RangeAttribute i zrobić walidację zakresu wewnątrz metody Validate lub chciałbym utworzyć niestandardowy atrybut podklasowania RangeAttribute, który bierze nazwę wymaganej właściwości jako argument konstruktora.

Na przykład:

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
class RangeIfTrueAttribute : RangeAttribute
{
    private readonly string _NameOfBoolProp;

    public RangeIfTrueAttribute(string nameOfBoolProp, int min, int max) : base(min, max)
    {
        _NameOfBoolProp = nameOfBoolProp;
    }

    public RangeIfTrueAttribute(string nameOfBoolProp, double min, double max) : base(min, max)
    {
        _NameOfBoolProp = nameOfBoolProp;
    }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        var property = validationContext.ObjectType.GetProperty(_NameOfBoolProp);
        if (property == null)
            return new ValidationResult($"{_NameOfBoolProp} not found");

        var boolVal = property.GetValue(validationContext.ObjectInstance, null);

        if (boolVal == null || boolVal.GetType() != typeof(bool))
            return new ValidationResult($"{_NameOfBoolProp} not boolean");

        if ((bool)boolVal)
        {
            return base.IsValid(value, validationContext);
        }
        return null;
    }
}

Podobała mi się odpowiedź cocogzy z wyjątkiem tej bazy połączeń.IsValid wywołał wyjątek przepełnienia stosu, ponieważ ponownie wprowadzał metodę IsValid. Więc zmodyfikowałem go do określonego rodzaju walidacji, w moim przypadku było to dla adresu e-mail.

[AttributeUsage(AttributeTargets.Property)]
class ValidEmailAddressIfTrueAttribute : ValidationAttribute
{
    private readonly string _nameOfBoolProp;

    public ValidEmailAddressIfTrueAttribute(string nameOfBoolProp)
    {
        _nameOfBoolProp = nameOfBoolProp;
    }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        if (validationContext == null)
        {
            return null;
        }

        var property = validationContext.ObjectType.GetProperty(_nameOfBoolProp);
        if (property == null)
        {
            return new ValidationResult($"{_nameOfBoolProp} not found");
        }

        var boolVal = property.GetValue(validationContext.ObjectInstance, null);

        if (boolVal == null || boolVal.GetType() != typeof(bool))
        {
            return new ValidationResult($"{_nameOfBoolProp} not boolean");
        }

        if ((bool)boolVal)
        {
            var attribute = new EmailAddressAttribute {ErrorMessage = $"{value} is not a valid e-mail address."};
            return attribute.GetValidationResult(value, validationContext);
        }
        return null;
    }
}