Validation d'objets avec FluentValidation

Dans cet article, nous allons apprendre à utiliser la bibliothèque FluentValidation et créer des validations simples et fortement typées.

Si vous travaillez avec le langage C# ou si vous vous y préparez, quelque chose qui vous accompagnera toujours est la validation des objets et de leurs propriétés. Mais cela peut être simple et facile, tant que vous utilisez les bons outils.

Qu'est-ce que FluentValidation ?

FluentValidation est une bibliothèque très populaire créée dans le but de rendre les validations de données simples et rapides.[19659005] Grâce à cela, nous pouvons utiliser des expressions Lambda pour créer des règles de validation et renvoyer des messages d'erreur pour chaque objet ou propriété non valide.

Approche pratique

Pour utiliser FluentValidation en pratique, nous allons créer une application console dans .NET 5 et installez la bibliothèque FluentValidation.

Vous pouvez accéder au code complet du projet sur ce lien : Code source de l'application FluentValidation.

Tout d'abord, ouvrez votre IDE C# préféré. Dans cet exemple, je vais utiliser Visual Studio 2019. Cliquez sur "Créer un nouveau projet" –> "Application console" –> Écrivez le nom de l'application (ValidationExampleApp) –> .NET 5 –> Créer.[19659005]Dans le projet, créez un dossier appelé "Models", et à l'intérieur, créez une classe appelée "Product" et remplacez son code par ceci :

using Système ;
utilisant Système.Collections.Générique ;

espace de noms ValidationExampleApp[194590].
{
    public class Product
    {
        public Product(IEnumerable<590Item ] produits)
        {
            this.Produits = produits;
        }

        public IEnumerable Produits ]Article
    {
        public Article(int id, chaîne nom,
            chaîne vendeur , chaîne catRefId, décimal quantité)
        {
            ceci.50505050  =  Vendeur 

Maintenant, téléchargez la bibliothèque FluentValidation. Vous pouvez utiliser NuGet Package Manager dans Visual Studio. La version utilisée dans cet exemple est 10.3.3.

Dans ce scénario, nous aurons une entité appelée Product qui recevra une liste d'éléments. Notre objectif sera de valider les propriétés de cet objet au fur et à mesure de leur remplissage.

Commençons par créer une classe statique où les messages d'erreur sera si les entrées dans les champs ne sont pas valides. 19659005]Ouvrez la classe et remplacez votre code par ceci :

espace de noms ValidationExampleApp.Erreurs
{
    public statique classe ProductErrors
    {
        public statique chaîne IdErrorMessage 20{01[9659017]20 ]; set; } = "Le champ ID ne peut pas être nul ou vide.";
        public static string ProductErrorMessage { get; set; } = "Le champ de produit ne peut pas être nul ou vide.";
        public  static string NameErrorMessage { get; set; } = "Le champ de nom ne peut pas être nul ou" vide.";
        public statique chaîne SellerErrorMessage { get; set; }13 = "Le champ Vendeur ne peut pas être nul ou vide.";
        public static  string CatRefIdErrorMessage { get; set; } = "Le champ CatRefId ne peut pas être nul ou vide."[196]59020 
        public static string QuantityErrorMessage { get; set; } = = = = = =  doit être supérieur à 0.";
    }
}

Nous pouvons maintenant créer la classe de validation. Il héritera de la classe "AbstractValidator" qui recevra en paramètre la classe à valider, en l'occurrence "Product".

Pour cela, au sein de la projet, créez un nouveau dossier appelé "Validators", et dans celui-ci, créez une classe appelée "ProductValidator".

Puis, à l'intérieur, collez le code suivant :

en utilisant  flueuretvalidation ;  Système .  LINQ ;  Utilisation de  ValidationExampleApp . Erreurs ; 
    ; 
; ]en utilisant ValidationExampleApp.Modèles;

espace de noms ValidationExampleApp.Validateurs
 {
     Public   Classe   ProductValidator  :  AbstractValidator  <> 
     {
         PublicValidator [19659020]()
        {
            RèglePour(x => x.Produits[19459065])[19459065]1].  Notnull  (
                ) .  WithMessage  ( .  ProducteurRormESSAGE [19459195])  Doit [19659020](x => x.Tout())
                .Avec message[19](590) Erreurs de produit.Message d'erreur de produit) ;

Règle pour(x =>041 x41904].041 ]Produits.Sélectionner(p => p.Id ))
.Doit(x =>  !x.N'importe lequel[1965]s => s <= 0))
            	.AvecMessageErreur (AvecMessageErreur ((90 ].IdErrorMessage);

            RèglePour(x => x. Sélectionnez(p => p.Vendeur)))
               .
               .
               . ](n => !n.Tout(s =>[1565]chaîne .IsNullOrEmpty(s) || chaîne.IsNullOrWhiteSpace[90]s[19545]((( 19659020]))
               .Avec message( ProducterRors .  (19659017]) 
    ) 
            
            ; 
            
             (19459020] ( = [19459194]>  x . . Produits.Sélectionnez(p => p.Nom))[196591].[196591]. 19659196]Doit(x => !x.Tout(s [20459004]s [20459004] > chaîne.IsNullOrEmpty(s) || chaîne.IsNullOrWhiteSpace190[190] )))
                .AvecMessage(ProductErrors.NameErrorMessage)2;2;2;2; ](x => x.Produits.Sélectionner(p =[1965 p.CatRefId))
                .Doit(x =>  ![4] .Tout(s => chaîne.IsNullOrEmpty(s[194|)1965]s[194|)1965]5131]   String .  Isnullorwhitepace  () 
    ) ) ) 
                ) .  WithMessage  ( ProducterRors .CatRefIdErrorMessage) ;

            RèglePour(x => x.[4]4590]. Sélectionner(p => p.Quantité)))
               .
               .
               . ](x => !x.Tout(s =>>>>> <= 0))[1 9659243].AvecMessage(ProductErrors.QuantityErrorMessage) ;
        }
    }[1965913965] , la classe "ProductValidator" contient dans son constructeur certaines méthodes nécessaires pour valider l'entité "Product" et ses propriétés. Avec FluentValidation, nous pouvons vérifier si les propriétés sont vides ou nulles, et aussi si les champs numériques sont supérieurs à zéro. 

 Créons maintenant les méthodes responsables de la mise en œuvre de la validation de l'entité Product. 
 Ainsi, dans le fichier Program, remplacez l'existant. code avec le code ci-dessous - ne vous inquiétez pas, nous verrons bientôt l'explication de chacune des méthodes. 
 en utilisant  FluentValidation . ] Fluentevalidationexample . ; ;  Utilisation de . . . ; ; Système  ; 
    ; 
    ;  Système.Collections.Générique ;
utilisant Système.Linqespace de noms ;0;0Linq;0;0Linq;0 ] FluentValidationExemple
{
    public class Program
    {
        public static void Main(chaîne  ]] args)
        {
            var produit = FillProductReady()5 résultat var[1965917] ;[1965919]  =   ValidateProduit  () 
    ) 

            ; 

             Si   ([19459194]! .  Isvalid )
            {
                Console.WriteLine("Les erreurs suivantes se sont produites : ") ;
                resultValidator.Erreurs.ToList().ForEach(x [194590960]x [194590960] 19659019]Imprimer les messages d'erreur(x.Message d'erreur)) ;
            }
        }

         RemplirProduitPrêt()
        {
            var article = nouveau Article(0[15659020]00 19659020], null, null, 0);
            var listItem =[1659]6159 Liste<Article>() ;
            listItem.Ajouter(item);
            return new Product(listItem590[17]listItem590 19659020]; 
        } 

         Static  validationResult  ValidateProduction  ( (19459017])   = > 
             Neuf   ProductValidator [19659020]().Valider(product);

        static void PrintErrorMessages(19659020]  message d'erreur) =>
            Console.WriteLine($"* {errorMessage}");
    }
}
Nous avons d'abord créé un méthode appelée "FillProductReady" qui est responsable du remplissage de l'entité Product avec des valeurs. Notre objectif est de valider ces champs, nous définissons donc les propriétés avec des valeurs nulles et attribuons leur retour à une variable "var product".
Ensuite, nous créons une méthode appelée "ValidateProduct " qui implémentera la méthode "Validate" de la bibliothèque FluentValidation, recevra une instance de notre variable Product et renverra un objet de type "ValidationResult".
Avec le résultat de la validation, on peut savoir si l'objet validé est valide ou non. S'il n'est pas valide, nous imprimerons un message d'erreur informant l'utilisateur des champs erronés.
Si vous avez suivi toutes les étapes précédentes, vous pouvez exécuter l'application et trouver la sortie suivante dans la console.
Notre objet a été validé et, comme il n'a pas passé les règles de validation que nous avons implémentées dans le ProductValidator », les messages d'erreur correspondant à chaque champ invalide étaient affichés. Ainsi, nous avons déjà un moyen simple de valider des objets sans beaucoup de "if/else", grâce à FluentValidation.
Conclusion
C'était une démonstration de l'utilisation de la bibliothèque FluentValidation pour implémenter des règles de validation. Il existe également d'autres moyens de le faire. L'important est d'utiliser ce qui correspond le mieux à vos besoins.