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é deapplications logicielles en utilisant les fonctions sophistiquées de production de PDF d'IronPDF et les solides 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 fluide: Flunt offre une interface lisible et succincte pour construire des règles de validation, ce qui simplifie l'expression d'une logique de validation complexe.

Validation enchaînable: Des scénarios de validation enchaî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 élargissant le cadre de Flunt, les développeurs peuvent ajouter des règles de validation personnalisées qui permettent une logique de validation adaptée aux exigences d'un domaine particulier.

Système de notification: Pour signaler les problèmes de validation et recueillir 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 des bibliothèques bien connus, notamment Entity Framework et ASP.NET Core, ce qui simplifie l'ajout d'une logique de validation à des projets déjà existants.

Testabilité: Flunt facilite le développement piloté par les tests(DRT) en offrant une séparation distincte entre le code de l'application et la logique de validation, ce qui facilite le test unitaire des règles de validation.

Source ouverte et communauté florissante : Un groupe de développeurs s'occupe activement de la maintenance de Flunt, ce qui en fait un logiciel libre. 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 mis en œuvre par de nombreux types d'applications C#, notamment Windows Console, les applications web et 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

Classe "Personne": La même que dans l'exemple de FluentValidation.

ContratPersonne: Cette classe dérive du concept fondamental de Flunt de Contrat.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.** Avec l'objet, il crée une instance dePersonContract` et un objet Person. 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 fluent.

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 en tant qu'alertes et répondez-y poliment en donnant aux utilisateurs des messages d'erreur ou en enregistrant les erreurs à des fins de 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 à de nombreux frameworks et bibliothèques .NET bien connus, notamment 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 d'IronPDF, la compatibilité et les autres choix de téléchargement, consultez son site webPage de détails du paquet NuGet sur le site web de 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, visitez le site suivantPage de téléchargement d'IronPDF ZIP. 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. **Une classe Personne est définie avec des attributs pour le nom et l'âge. 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 elle accepte un objet User comme entrée. Cette fonction convertit le texte HTML représentant le résumé de l'enregistrement de l'utilisateur en un document PDF en utilisant la classe HtmlToPdf d'IronPDF.

3. Méthode principale: En utilisant les données de l'échantillon Person, 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, reportez-vous à la page d'accueil du sitepage 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 à jour de la bibliothèque sont inclus dans l'offre $749 Lite. IronPDF fournitdétails sur les licences gratuites d'IronPDF pour plus de détails concernant le coût et les conditions de licence. Pour plus d'informations sur les bibliothèques d'Iron Software, visitez le site web de l'entrepriseSite web officiel d'Iron Software.