Comment valider des classes dans une hiérarchie d'une manière générique en toute sécurité?

Question

Je suis coincé avec ce qui semblait être une tâche très simple au tout début. J'ai une hiérarchie de classe dans laquelle chaque classe peut définir ses propres règles de validation. Définir les règles de validation devrait être aussi simple que possible. Voici à peu près ce dont vous avez besoin:

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

Il y a encore une chose à faire: sécuriser le type lors de l'ajout de règles de validation. Sinon, chaque sous-classe devra faire ces moulages qui semblent juste gênants. Idéalement, Func<T, bool> fonctionnerait, mais il y a tout un tas de problèmes avec cela: nous ne pouvons pas hériter de HierarchyBase de n'importe quel type de IValidatable<HierarchyBase> car la hiérarchie d'héritage peut être N niveaux profonds (ouais, je sens l'odeur aussi); stocker du béton Func<HierarchyBaseInheritor, bool> dans rules et de les traverser.

Comment introduiriez-vous la sécurité de type ici?

Answer 1

La bonne approche est de faire de chaque classe dans la hiérarchie responsable de se valider:

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

Utilisation:

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

Answer 2

Note: La solution suivante est une blague en entre moi et Eric Lippert. Cela fonctionne, mais n'est probablement pas à recommander.

L'idée est de définir un paramètre de type générique qui fait référence au type "courant" (comme this fait référence à l'objet "courant").

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

Utilisation:

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