Как проверить классы в иерархии общим безопасным для типов способом?

Question

Я застрял с тем, что казалось очень простой задачей в самом начале. У меня есть иерархия классов каждого класса, в которой можно определить свои собственные правила проверки. Определение правил валидации должно быть максимально простым. Вот что почти необходимо:

class HierarchyBase
{

    private List<Func<object, bool>> rules = new List<Func<object, bool>>();
    public int fieldA = 0;

    public HierarchyBase()
    {
        AddRule(x => ((HierarchyBase)x).fieldA % 2 == 0);
    }

    protected virtual void Operation()
    {
        fieldA++;
    }

    protected void AddRule(Func<object, bool> validCriterion)
    {
        rules.Add(validCriterion);
    }

    public void PerformOperation()
    {
        Operation();
        Validate();
    }

    protected virtual void Operation()
    {
        fieldA++;
    }

    private void Validate()
    {
        IsValid = rules.All(x => x(this));
    }

    public bool IsValid
    {
        get;
        private set;
    }
}

Есть еще одна вещь, которая необходима - безопасность типов при добавлении правил проверки. В противном случае каждый подкласс должен будет выполнять те броски, которые просто выглядят неловко. В идеале Func<T, bool> будет работать, но есть целый ряд проблем с этим: мы не можем наследовать HierarchyBase от любого вида IValidatable<HierarchyBase>, поскольку иерархия наследования может иметь N уровней глубины (да, я чувствую запах ); хранение любого бетона Func<HierarchyBaseInheritor, bool> в rules и его прохождение.

Как бы вы представили здесь безопасность типов?

Answer 1

Примечание: Следующее решение - шутка между мной и Эриком Липпертом.Это работает, но, вероятно, не рекомендуется.

Идея состоит в том, чтобы определить параметр универсального типа, который ссылается на «текущий» тип (например, this относится к «текущему» объекту).

HierarchyBase:

class HierarchyBase<T>
    where T : HierarchyBase<T>
{
    protected readonly List<Func<T, bool>> validators;

    public HierarchyBase()
    {
        validators = new List<Func<T, bool>>();
        validators.Add(x => x.A % 2 == 0);
    }

    public int A { get; set; }

    public bool Validate()
    {
        return validators.All(validator => validator((T)this));
    }
}

HierarchyBaseInheritorA:

class HierarchyBaseInheritorA<T> : HierarchyBase<T>
    where T : HierarchyBaseInheritorA<T>
{
    public HierarchyBaseInheritorA()
    {
        validators.Add(x => x.A > 10);
        validators.Add(x => x.B != 0);
    }

    public int B { get; set; }
}

HierarchyBaseInheritorB:

class HierarchyBaseInheritorB : HierarchyBaseInheritorA<HierarchyBaseInheritorB>
{
    public HierarchyBaseInheritorB()
    {
        validators.Add(x => x.A < 20);
        validators.Add(x => x.B > 0);
        validators.Add(x => x.C == 0);
    }

    public int C { get; set; }
}

Использование:

var result = new HierarchyBaseInheritorB();
result.A = 12;
result.B = 42;
result.C = 0;
bool valid = result.Validate(); // == true

Answer 2

Правильный подход заключается в том, чтобы каждый класс в иерархии отвечал за свою валидацию:

HierarchyBase:

class HierarchyBase
{
    public int A { get; set; }

    public bool Validate()
    {
        return this.OnValidate();
    }

    protected virtual bool OnValidate()
    {
        return (this.A % 2 == 0);
    }
}

HierarchyBaseInheritorA:

class HierarchyBaseInheritorA : HierarchyBase
{
    public int B { get; set; }

    protected override bool OnValidate()
    {
        return base.OnValidate() &&
               (this.A > 10) &&
               (this.B != 0);
    }
}

HierarchyBaseInheritorB:

class HierarchyBaseInheritorB : HierarchyBaseInheritorA
{
    public int C { get; set; }

    protected override bool OnValidate()
    {
        return base.OnValidate() && 
               (this.A < 20) &&
               (this.B > 0) &&
               (this.C == 0);
    }
}

Использование:

var result = new HierarchyBaseInheritorB();
result.A = 12;
result.B = 42;
result.C = 0;
bool valid = result.Validate(); // == true