Flunt C# (Comment ça marche pour les développeurs)

Introduction

Dans l'environnement actuel de développement de logiciels, la production d'une documentation de qualité et la garantie de l'intégrité des données sont des tâches essentielles. Dans ce billet, nous verrons comment combiner les puissantes bibliothèques C#, Flunt C# et IronPDF afin d'améliorer les flux de travail pour la validation des données et la création de documents. Les développeurs peuvent construire des solutions efficaces et fiables pour une variété d'applications logicielles en utilisant les fonctionnalités sophistiquées de production de PDF de IronPDF et les puissantes capacités de validation de Flunt.

Comment utiliser Flunt dans C# ;

1. Créez un nouveau projet de console C#.

2. Installez le paquetage Flunt depuis Nuget.

3. Importez l'espace de noms et héritez de la classe.

4. Ajouter la validation au modèle de données.

5. Effectuer des contrôles de validation et afficher le résultat.

Compréhension de la C# ;

Le Framework .NET polyvalent et léger, Flunt, a été créé pour faciliter le développement de modèles de validation et de notification fluides dans les applications C#. Le code devient plus lisible et plus facile à maintenir lorsque les développeurs utilisent Flunt pour construire des règles de validation et une logique d'entreprise d'une manière fluide et expressive. Grâce à la gamme étendue de techniques de validation intégrées et d'extensions de Flunt, les développeurs peuvent facilement valider des structures de données complexes telles que les objets et les collections.

En outre, Flunt est un outil utile pour renforcer la fiabilité et la robustesse des applications de la bibliothèque NET, car il s'intègre facilement aux bases de code et aux cadres de travail actuels. Dans l'ensemble, Flunt encourage une approche déclarative de la validation et de la gestion des erreurs, ce qui permet aux développeurs d'écrire un code plus propre et plus robuste.

Caractéristiques de Flunt C&num ;

Interface fluente : Flunt offre une interface lisible et concise pour créer des règles de validation, ce qui simplifie l'expression de logiques de validation complexes.

Validation chaînable : Des scénarios de validation chaînables peuvent être créés avec peu de code en connectant naturellement les règles de validation.

Validateurs intégrés : Flunt est livré avec plusieurs validateurs intégrés pour les types de données fréquemment utilisés, y compris les dates, les entiers, les chaînes de caractères et les collections. Une syntaxe fluide permet d'appliquer facilement ces validateurs aux propriétés.

Règles de validation personnalisées : En étendant le cadre Flunt, les développeurs peuvent ajouter des règles de validation personnalisées qui permettent une logique de validation adaptée aux exigences particulières du domaine.

Système de notification : Pour signaler les problèmes de validation et collecter les messages d'erreur, Flunt propose un système de notification. Les développeurs peuvent ainsi facilement informer les utilisateurs ou d'autres composants de l'application des échecs de validation.

Intégration avec les Frameworks : Flunt se connecte facilement avec des frameworks et bibliothèques bien connus, y compris Entity Framework et ASP.NET Core, ce qui simplifie l'ajout de logique de validation à des projets déjà existants.

Testabilité : Flunt facilite le développement dirigé par les tests (TDD) en offrant une division claire entre le code de l'application et la logique de validation, ce qui permet de tester facilement les règles de validation unitairement.

Open Source et communauté florissante : Un groupe de développeurs maintient activement Flunt, le rendant open-source. Cela garantit la poursuite de la maintenance, des améliorations et de l'assistance pour le cadre.

Premiers pas avec C# ;

Mise en place de Flunt dans C# ; Projets

L'espace de noms Notifications et Validation fait partie de la bibliothèque de classes de base Flunt et devrait être accessible par défaut dans votre projet C#. Flunt accélère la validation des programmes C# en fournissant une interface flexible pour définir et appliquer des règles de validation. Sa prise en charge d'un code plus propre, d'une meilleure lisibilité et d'une gestion approfondie des erreurs facilite la validation des entrées utilisateur, des objets du domaine et des demandes d'API.

Mise en œuvre de Flunt dans la console et les formulaires Windows

Flunt est implémenté par de nombreux types d'applications C#, y compris les applications Console Windows, les applications web et les Windows Forms (WinForms). Bien que chaque cadre ait une mise en œuvre différente, le concept général est toujours le même.

C# ; Exemple

Vous pouvez utiliser le code suivant Flunt dès qu'il est installé. Il s'agit d'un exemple simple qui montre comment utiliser Flunt pour construire des règles de validation :

using Flunt.Validations;
static void Main(string[] args)
{
    var person = new Person { Name = "Jack", Age = -25 };
    var contract = new PersonContract(person);
    // validation checks
    if (contract.IsValid)
    {
        Console.WriteLine("Person is valid!");
    }
    else
    {
            Console.WriteLine("Validation failed:");
            foreach (var notification in contract.Notifications)
            {
                Console.WriteLine($"- {notification.Key}:{notification.Message}");
            }
    }
}
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
public class PersonContract : Contract<Person>
{
public PersonContract(Person person)
    {
        // ensure the correct format of the object
        Requires()
            .IsNotNull(person, nameof(person))
        .IsNotEmpty(person.Name, nameof(person.Name), "Name is required")
            .IsGreaterThan(person.Age, 0, nameof(person.Age), "Age must be a positive number");
    }
}

using Flunt.Validations;
static void Main(string[] args)
{
    var person = new Person { Name = "Jack", Age = -25 };
    var contract = new PersonContract(person);
    // validation checks
    if (contract.IsValid)
    {
        Console.WriteLine("Person is valid!");
    }
    else
    {
            Console.WriteLine("Validation failed:");
            foreach (var notification in contract.Notifications)
            {
                Console.WriteLine($"- {notification.Key}:{notification.Message}");
            }
    }
}
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
public class PersonContract : Contract<Person>
{
public PersonContract(Person person)
    {
        // ensure the correct format of the object
        Requires()
            .IsNotNull(person, nameof(person))
        .IsNotEmpty(person.Name, nameof(person.Name), "Name is required")
            .IsGreaterThan(person.Age, 0, nameof(person.Age), "Age must be a positive number");
    }
}

Imports Flunt.Validations
Shared Sub Main(ByVal args() As String)
	Dim person As New Person With {
		.Name = "Jack",
		.Age = -25
	}
	Dim contract = New PersonContract(person)
	' validation checks
	If contract.IsValid Then
		Console.WriteLine("Person is valid!")
	Else
			Console.WriteLine("Validation failed:")
			For Each notification In contract.Notifications
				Console.WriteLine($"- {notification.Key}:{notification.Message}")
			Next notification
	End If
End Sub
Public Class Person
Public Property Name() As String
Public Property Age() As Integer
End Class
Public Class PersonContract
	Inherits Contract(Of Person)

Public Sub New(ByVal person As Person)
		' ensure the correct format of the object
		Requires().IsNotNull(person, NameOf(person)).IsNotEmpty(person.Name, NameOf(person.Name), "Name is required").IsGreaterThan(person.Age, 0, NameOf(person.Age), "Age must be a positive number")
End Sub
End Class

Person Classe : La même chose que dans l'exemple de FluentValidation.

PersonContract : Cette classe dérive du concept fondamental de Flunt, Contract.Verifications. En utilisant la méthode Requires, le constructeur prend un objet Person et fournit des règles de validation. Requires offre une méthode chaînable pour ajouter plusieurs validations. Les validations sont effectuées par des méthodes telles que IsNotNull, NotEmpty, HasMinLength, et IsGreaterThan. Pour chaque règle de validation, des messages d'erreur personnalisés sont disponibles.

Validation : Comparable à l'exemple de FluentValidation.Together avec l'objet, il crée une instance de PersonContract et un objet Personne. Le résultat de la validation est indiqué par l'attribut Valid du contrat. En fonction du résultat de la validation, des notifications de réussite ou d'échec ainsi que des détails d'erreur particuliers sont affichés.

Opérations d'abattage

Pour la validation et la gestion des notifications dans les applications C#, Flunt propose de nombreuses opérations, telles que :

Création de règles de validation : Pour créer des règles de validation pour des attributs tels que les champs obligatoires, les types de données, les plages de valeurs, la longueur maximale et la longueur minimale, utilisez l'interface fluide.

Exécution de la validation : Pour garantir l'intégrité des données et le respect de la logique commerciale, les objets sont validés par rapport à des règles prédéfinies.

Gestion des erreurs de validation : Notez et enregistrez les erreurs de validation sous forme d'alertes et répondez-y poliment en fournissant aux utilisateurs des messages d'erreur ou en enregistrant les erreurs pour le dépannage. Logique de validation personnalisée Utilisez des règles de validation uniques pour étendre Flunt en réponse à des circonstances de validation complexes ou à des exigences de domaine particulières.

Intégration avec les frameworks : Pour améliorer les capacités de validation dans les applications actuelles, Flunt peut être intégré de manière transparente avec de nombreux frameworks et bibliothèques .NET bien connus, y compris Entity Framework, ASP.NET Core, et plus encore.

Intégrer Flunt à IronPDF

Les développeurs peuvent exploiter les forces des deux technologies pour accélérer la validation de la logique commerciale et la création de documents dans les applications C# en intégrant Flunt à IronPDF. Les applications peuvent être rendues plus fiables et plus conviviales par les développeurs en utilisant IronPDF pour créer des documents PDF après avoir validé les données d'entrée avec Flunt.

Installer IronPDF

• Lancez le projet Visual Studio.
• Sélectionnez "Outils" > "NuGet Package Manager" > "Console du gestionnaire de paquets".
• Saisissez cette commande dans la console du gestionnaire de paquets :

Install-Package IronPdf

• Vous pouvez également utiliser NuGet Package Manager for Solutions pour installer IronPDF et les autres paquets NuGet nécessaires.

• Cliquez sur le bouton "Installer" après avoir exploré et choisi le paquet IronPDF dans les résultats de la recherche. L'installation et le téléchargement seront pris en charge par Visual Studio.

  

• L'installation du paquetage IronPDF et de toutes les dépendances nécessaires à votre projet sera prise en charge par NuGet.
• Après l'installation, IronPDF est disponible pour être utilisé dans votre projet.

Installation via le site Web de NuGet

Pour en savoir plus sur les fonctionnalités, la compatibilité et les autres choix de téléchargement d'IronPDF, consultez sa page de détails du package NuGet sur le site NuGet.

Utiliser la DLL pour l'installation

Vous pouvez également utiliser le fichier DLL d'IronPDF pour l'inclure directement dans votre projet. Pour obtenir le fichier ZIP contenant la DLL, rendez-vous sur la page de téléchargement du ZIP IronPDF. Une fois la DLL décompressée, incluez-la dans votre projet.

Mise en œuvre de la logique

Créons une application C# de base qui utilise IronPDF pour la création de PDF et Flunt pour la validation des données. Dans cet exemple, nous utiliserons Flunt pour valider les données saisies par l'utilisateur dans un formulaire d'inscription, et IronPDF pour créer un document PDF contenant un résumé des données de l'utilisateur qui ont été vérifiées.

1. Classe Personne : Une classe Personne avec des attributs pour le nom et l'âge est définie. Nous validons les données de la personne en fonction de règles de validation prédéfinies en utilisant l'interface fluide de Flunt dans le constructeur.

2. Générer un Pdf : Une méthode appelée RenderHtmlAsPdf est définie et accepte un objet User en entrée. Cette fonction rend le texte HTML représentant le résumé de l'inscription de l'utilisateur dans un document PDF en utilisant la classe HtmlToPdf de IronPDF.

3. Méthode Principale : En utilisant des données d'exemple de Personne, nous construisons une instance de la classe User dans la méthode Main. Ensuite, nous utilisons l'attribut IsValid de Flunt pour déterminer si les données de la personne sont légitimes. Pour créer le document PDF, nous invoquons la méthode IronPDF si les données sont correctes. Si ce n'est pas le cas, les problèmes de validation sont affichés sur la console.

   Nous avons développé un flux de travail rapide pour évaluer les entrées des utilisateurs et produire des documents PDF dans une application C# en combinant IronPDF pour la génération de PDF avec Flunt pour la validation des données. Cette méthode garantit l'intégrité des données, génère des documents de qualité professionnelle et encourage l'écriture d'un code clair, lisible et facile à maintenir. Pour en savoir plus sur les capacités d'IronPDF, consultez la page de documentation. Vous trouverez ci-dessous un exemple de code.

using IronPdf;
using System;
using System.Linq;
using System.Text;
using Flunt.Validations;
namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            StringBuilder sb = new StringBuilder();
            var person = new Person { Name = "Jack", Age = -25 };
            var contract = new PersonContract(person);
            if (contract.IsValid)
            {
                Console.WriteLine("Person is valid!");
            }
            else
            {
                sb.Append("<p>Validation failed: </p>");
                foreach (var notification in contract.Notifications)
                {
                    sb.Append($"- {notification.Key}: {notification.Message}");
                }
            }
            var renderer = new IronPdf.HtmlToPdf();
            //Set HTML content for the page
            var pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString());
            // save the document
            pdfDocument.SaveAs("output.pdf");
            //Dispose the render object
            renderer.Dispose();
            //Display a message
            Console.WriteLine("Report generated successfully!");
        }
    }
    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
    public class PersonContract : Contract<Person>
    {
        public PersonContract(Person person)
        {
            Requires()
                .IsNotNull(person, nameof(person))
            .IsNotEmpty(person.Name, nameof(person.Name), "Name is required")
                .IsGreaterThan(person.Age, 0, nameof(person.Age), "Age must be a positive number");
        }
    }
}

using IronPdf;
using System;
using System.Linq;
using System.Text;
using Flunt.Validations;
namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            StringBuilder sb = new StringBuilder();
            var person = new Person { Name = "Jack", Age = -25 };
            var contract = new PersonContract(person);
            if (contract.IsValid)
            {
                Console.WriteLine("Person is valid!");
            }
            else
            {
                sb.Append("<p>Validation failed: </p>");
                foreach (var notification in contract.Notifications)
                {
                    sb.Append($"- {notification.Key}: {notification.Message}");
                }
            }
            var renderer = new IronPdf.HtmlToPdf();
            //Set HTML content for the page
            var pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString());
            // save the document
            pdfDocument.SaveAs("output.pdf");
            //Dispose the render object
            renderer.Dispose();
            //Display a message
            Console.WriteLine("Report generated successfully!");
        }
    }
    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
    public class PersonContract : Contract<Person>
    {
        public PersonContract(Person person)
        {
            Requires()
                .IsNotNull(person, nameof(person))
            .IsNotEmpty(person.Name, nameof(person.Name), "Name is required")
                .IsGreaterThan(person.Age, 0, nameof(person.Age), "Age must be a positive number");
        }
    }
}

Imports IronPdf
Imports System
Imports System.Linq
Imports System.Text
Imports Flunt.Validations
Namespace ConsoleApp
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			Dim sb As New StringBuilder()
			Dim person As New Person With {
				.Name = "Jack",
				.Age = -25
			}
			Dim contract = New PersonContract(person)
			If contract.IsValid Then
				Console.WriteLine("Person is valid!")
			Else
				sb.Append("<p>Validation failed: </p>")
				For Each notification In contract.Notifications
					sb.Append($"- {notification.Key}: {notification.Message}")
				Next notification
			End If
			Dim renderer = New IronPdf.HtmlToPdf()
			'Set HTML content for the page
			Dim pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString())
			' save the document
			pdfDocument.SaveAs("output.pdf")
			'Dispose the render object
			renderer.Dispose()
			'Display a message
			Console.WriteLine("Report generated successfully!")
		End Sub
	End Class
	Public Class Person
		Public Property Name() As String
		Public Property Age() As Integer
	End Class
	Public Class PersonContract
		Inherits Contract(Of Person)

		Public Sub New(ByVal person As Person)
			Requires().IsNotNull(person, NameOf(person)).IsNotEmpty(person.Name, NameOf(person.Name), "Name is required").IsGreaterThan(person.Age, 0, NameOf(person.Age), "Age must be a positive number")
		End Sub
	End Class
End Namespace

Voici le résultat de l'exécution du code ci-dessus :

Conclusion

IronPDF et Flunt sont deux solides bibliothèques C# qui fonctionnent bien ensemble pour rationaliser les flux de travail pour la création de documents et la validation des données. Grâce aux fonctions sophistiquées de production de PDF d'IronPDF et aux solides capacités de validation de Flunt, les développeurs peuvent élaborer des solutions fiables, efficaces et de haute qualité pour une grande variété d'applications. Flunt et IronPDF dotent les développeurs des outils nécessaires pour créer des logiciels de haute qualité qui répondent aux besoins des utilisateurs et des parties prenantes, qu'ils développent des applications de bureau, des applications web ou des solutions basées sur le cloud.

Un an de support logiciel, une licence permanente et une mise à niveau de la bibliothèque sont tous inclus dans le pack Lite $749. IronPDF fournit des détails de licence gratuits d'IronPDF pour plus d'informations concernant le coût et les exigences de licence. Pour plus d'informations sur les bibliothèques Iron Software, visitez le site officiel d'Iron Software.