FluentObjectValidator

FluentObjectValidator

FluentObjectValidator est une bibliothèque de validation petite et simple qui fournit une interface fluide pour la configuration des règles.

La bibliothèque est destinée à fournir une alternative à la validation basée sur l'attribut d'un modèle (requiredAttribute, stringLengthAttribute, etc.).

Condition préalable

La bibliothèque cible .NET Standart 1.0, .NET 4.0, .NET 4.5

Installation

La bibliothèque est disponible en tant que package NuGet.

Commencer

Voici les étapes qui vous aideront à configurer la validation de votre application.

• Choisissez le résultat
• Configurer les règles
• Valider

Choisissez le résultat

Tout d'abord, vous devrez décider des informations que vous souhaitez recevoir, lorsqu'un certain modèle n'a pas réussi la validation.

Les principales classes qui fournissent la fonctionnalité de validation sont:

• Validator - Renvoie une valeur booléenne qui indique que la validation passée ou non.
• Validator<TError> - Renvoie une instance d'objet ValidationResult<TError> , qui contient une valeur booléenne, et une collection d'objets TError personnalisés qui vous montrent exactement, laquelle des règles n'a pas adopté.

Après avoir décidé quel validateur utiliser, tout ce que vous avez à faire est de l'hériter de celui-ci et d'ajouter les configurations, comme ainsi:

 public class MyValidator : Validator
{
    public MyValidator ( )
    {
        AddConfiguration ( new ProductDTOConfiguration ( ) ) ;
        AddConfiguration ( new UserDTOConfiguration ( ) ) ;
    }
} 

 public class MyValidator : Validator < MyCustomError >
{
    public MyValidator ( )
    {
        AddConfiguration ( new ProductDTOConfiguration ( ) ) ;
        AddConfiguration ( new UserDTOConfiguration ( ) ) ;
    }
}

Cela nous amène à l'étape suivante.

Configurer les règles

Pour configurer les règles que vos objets doivent suivre, vous devez créer des classes de configuration pour chacun des types que vous souhaitez valider.

Selon le validateur choisi, toutes les configurations héritent de ValidationConfiguration<TObject> ou ValidationConfiguration<TObject, TError> .

ValidationConfiguration<TObject>

 public class ProductDTOConfiguration : ValidationConfiguration < ProductDTO >
{
    public ProductDTOConfiguration ( )
    {
        Property ( x => x . Title )
            . IsRequired ( )
            . HasRule ( x => x . Length <= 10 ) ;
    }
}

Après avoir sélectionné la propriété, vous pouvez ajouter les règles de validation de manière courante.

Vous pouvez définir toutes les règles avec une méthode HasRule , mais il existe plusieurs raccourcis prédéfinis comme IsRequired disponibles pour tous les objets, et HasMinLength , HasMaxLength , HasLengthInRange , MatchesRegex disponible uniquement pour les chaînes.

La validation se produit séquentiellement dans un ordre, les règles ont été définies et renvoie false dès que l'une des règles n'a pas adopté, ou true si toutes ont été adoptées.

ValidationConfiguration<TObject, TError>

 public class ProductDTOConfiguration : ValidationConfiguration < ProductDTO , MyCustomError >
{
    public ProductDTOConfiguration ( )
    {
        Property ( x => x . Title )
            . IsRequired ( ( ) => new MyCustomError ( "Title is required" ) )
            . HasRule (
                x => x . Length <= 10 ,
                ( ) => new MyCustomError ( "Title is too long" ) ) ;
    }
}

La configuration de la validation, qui renvoie les erreurs personnalisées en cas d'échecs est un peu plus complexe.

Après avoir sélectionné une propriété et défini une règle, vous devez maintenant ajouter un délégué qui sera utilisé pour créer l'objet d'erreur si la règle ne passe pas.

La validation se produit également séquentiellement dans un ordre, les règles ont été définies, mais si l'une des règles ne passe pas, l'erreur est ajoutée au résultat et la validation se poursuit.

Vous pouvez configurer la validation pour sauter le reste des règles pour une propriété actuelle, ou pour l'objet entier, au cas où une règle spécifique ne passe pas. Cela peut être fait en passant par terminateValidationOnError stopValidationOnError la méthode HasRule . Les deux sont faux par défaut.

La méthode IsRequired saute toujours le reste des règles pour une propriété, car nous n'avons pas besoin de vérifier d'autres règles si la propriété est par exemple égale à NULL.

Les règles de raccourci comme IsRequired , HasMaxLength sont implémentées via des méthodes d'extension, vous pouvez donc facilement ajouter vos propres raccourcis à votre projet.

Valider

Après avoir configuré les règles, vous pouvez désormais créer l'instance de votre validateur et l'utiliser où vous le souhaitez.

 var res = validator . Validate ( obj ) ;

Chaque validateur expose une seule méthode publique «Valider», qui est disponible via des interfaces:

 public interface IValidator < TError >
{
    ValidationResult < TError > Validate < TObject > ( TObject target ) ;
}
    
public interface IValidator
{
    bool Validate < TObject > ( TObject target ) ;
}

C'est pourquoi vous pouvez facilement l'utiliser avec une injection de dépendance:

 services . AddSingleton < IValidator , MyValidator > ( ) 

 container . Register < IValidator < MyCustomError > , MyValidator > ( Lifestyle . Singleton ) ;

Toutes les configurations sont chargées et validées lors de la création de l'instance de validateur, donc à mon avis, il est préférable de l'utiliser comme singleton.

Licence

Ce projet est autorisé en vertu de la licence MIT - voir le fichier de licence pour plus de détails

Remerciements

La façon dont la configuration des règles se produit a été inspirée par l'entité Framework 6 et sa façon de configurer les relations entre les entités.