web-dev-qa-db-fra.com

C # FluentValidation pour une hiérarchie de classes

J'ai une hiérarchie de classes de données

public class Base
{
    // Fields to be validated
}

public class Derived1 : Base
{
    // More fields to be validated
}

public class Derived2 : Base
{
    // More fields to be validated
}

Quel serait le moyen approprié de valider Derived1 et Derived2 en utilisant le framework FluentValidation sans dupliquer les règles pour les champs de la classe de base?

c#fluentvalidation
29
Nikolay Nahimov

Une approche à adopter serait la suivante:

public class Base
{
    public string BaseName { get; set; } 
}

public class Derived1 : Base
{
    public string Derived1Name { get; set; }
}

public class BaseValidator<T> : AbstractValidator<T> where T : Base
{
    public BaseValidator()
    {
        RuleFor(b => b.BaseName).NotNull();
    }
}

public class Derived1Validator : BaseValidator<Derived1>
{
    public Derived1Validator()
    {
        RuleFor(d => d.Derived1Name).NotNull();
    }
}

Vous devez donc d'abord créer votre validateur de base, lui faire accepter un argument de type générique et spécifier que le type générique doit être de type base. Configurez vos règles générales pour votre classe de base et passez à autre chose.

Pour tous les validateurs qui valident les enfants de votre classe de base, vous avez ces validateurs hérités du baseValidator, où T sera votre type de classe dérivée.

36
Yannick Meeus
public class Derived2Validator : AbstractValidator<Derived2>
{
    public Derived2Validator()
    {
        Include(new BaseValidator());
        Include(new Derived2Validator());
        RuleFor(d => d.Derived1Name).NotNull();
    }
}

Derived2Validator n'a pas besoin d'hériter de BaseValidator ou Derived1Validator. La méthode Include inclura les règles des validateurs de base.

39
Mohsin Syed

J'ai essayé la méthode Include (), mais cela ne m'a pas donné les résultats souhaités car les modèles générés par swagger dans .net core ne présentaient aucun changement. qu'est-ce que le travail a été la création d'une nouvelle classe à hériter pour les validateurs qui ont une classe de base 

/// <summary>
/// Base Class for entity validator classes that specifies a base validator class
/// </summary>
/// <typeparam name="T">The Type being validated</typeparam>
/// <typeparam name="TBaseClass">The validater assigned to the base type of the type being validated</typeparam>
public abstract class BaseAbstractValidator<T, TBaseClass> : AbstractValidator<T>
    where TBaseClass : IEnumerable<IValidationRule>
{
    protected BaseAbstractValidator() => AppendRules<TBaseClass>();

    /// <summary>
    /// Add the set of validation rules
    /// </summary>
    /// <typeparam name="TValidationRule"></typeparam>
    private void AppendRules<TValidationRule>() where TValidationRule : IEnumerable<IValidationRule>
    {
        var rules = (IEnumerable<IValidationRule>)Activator.CreateInstance<TValidationRule>();
        foreach (var rule in rules)
        {
            AddRule(rule);
        }
    }
}
0
jonmeyer