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

Comment utiliser Flunt en C

1. Créer un nouveau projet console C#.
2. Installez le package Flunt depuis NuGet.
3. Importez l'espace de noms et héritez de la classe.
4. Ajoutez la validation au modèle de données.
5. Effectuez des vérifications de validation et affichez le résultat.

Comprendre Flunt C

Le cadre .NET polyvalent et léger, Flunt, a été conçu pour faciliter le développement de modèles de validation fluide et de notification dans les applications C#. Le code devient plus lisible et maintenu lorsque les développeurs utilisent Flunt pour construire des règles de validation et une logique métier de manière fluide et expressive. Avec la large gamme de techniques de validation intégrées et d'extensions de Flunt, les développeurs peuvent facilement valider des structures de données complexes comme des objets et des collections.

De plus, Flunt est un outil utile pour renforcer la fiabilité et la robustesse des applications de bibliothèques .NET puisqu'il s'intègre facilement avec les bases de code et les cadres existants. En fin de compte, Flunt encourage une approche déclarative de la validation et de la gestion des erreurs, permettant aux développeurs d'écrire un code plus propre et plus robuste.

Commencer avec Flunt C

Exemple de Flunt C

Vous pouvez utiliser le code suivant de Flunt aussitôt qu'il est installé. Voici un exemple simple qui vous montre comment utiliser Flunt pour construire des règles de validation :

using System;
using Flunt.Validations;

public class Program
{
    static void Main(string[] args)
    {
        var person = new Person { Name = "Jack", Age = -25 };
        var contract = new PersonContract(person);

        // Perform 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 System;
using Flunt.Validations;

public class Program
{
    static void Main(string[] args)
    {
        var person = new Person { Name = "Jack", Age = -25 };
        var contract = new PersonContract(person);

        // Perform 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 System
Imports Flunt.Validations

Public Class Program
	Shared Sub Main(ByVal args() As String)
		Dim person As New Person With {
			.Name = "Jack",
			.Age = -25
		}
		Dim contract = New PersonContract(person)

		' Perform 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
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)
		' 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 Person : Représente une entité avec les propriétés Name et Age.

PersonContract : Cette classe dérive du concept fondamental de Flunt, Contract<T>. 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 définir plusieurs validations. Les validations sont effectuées par des méthodes telles que IsNotNull, IsNotEmpty, IsGreaterThan. Chaque règle de validation a un message d'erreur personnalisé associé.

Validation : Similaire à un exemple de FluentValidation, cela crée une instance d'un PersonContract et d'un objet Person. Les résultats de la validation sont montrés par l'attribut IsValid du contrat. Les notifications de succès ou d'échec, ainsi que les messages d'erreur spécifiques, sont affichés en fonction du résultat de la validation.

Opérations de Flunt

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

Création de Règles de Validation : Pour créer des règles de validation pour des attributs comme 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 métier, validez les objets par rapport aux règles prédéfinies.

Gestion des Erreurs de Validation : Notez et enregistrez les erreurs de validation comme des alertes et répondez-y poliment en fournissant aux utilisateurs des messages d'erreur ou en enregistrant des erreurs pour les résoudre.

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 Cadres : Pour améliorer les capacités de validation dans les applications existantes, Flunt peut être intégré de manière transparente à de nombreux cadres et bibliothèques .NET bien connus, y compris Entity Framework, ASP.NET Core, et plus encore.

Intégration de Flunt avec IronPDF

Les développeurs peuvent exploiter les atouts des deux technologies pour accélérer la validation de la logique métier et la création de documents dans les applications C# en intégrant Flunt avec IronPDF. Les applications peuvent être rendues plus fiables et 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" > "Gestionnaire de Paquets NuGet" > "Console du Gestionnaire de Paquets".
• Entrez cette commande dans la console du gestionnaire de paquets :

Install-Package IronPdf

• Comme alternative, vous pouvez utiliser le Gestionnaire de Paquets NuGet pour Solutions pour installer IronPDF et d'autres paquets NuGet nécessaires.
• Cliquez sur le bouton "Installer" après avoir exploré et sélectionné le package IronPDF depuis les résultats de la recherche. L'installation et le téléchargement seront gérés par Visual Studio.

• L'installation du package IronPDF et de toutes dépendances nécessaires à votre projet sera gérée par NuGet.
• Après l'installation, IronPDF est disponible pour utilisation dans votre projet.

Implémentation de la logique

Créons une application C# basique 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 la saisie utilisateur pour un formulaire d'inscription, et IronPDF pour créer un document PDF avec un résumé des données utilisateur qui ont été vérifiées.

1. Classe Person : Une classe Person avec des attributs pour le nom et l'âge est définie. Nous validons les données de la Personne par rapport à des règles de validation prédéfinies en utilisant l'interface fluide de Flunt dans le constructeur.
2. Générer le Pdf : Une méthode appelée RenderHtmlAsPdf est définie, et elle accepte un objet User comme 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 d'IronPDF.
3. Méthode Principale : En utilisant des données d'exemple de Person, nous créons 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. Sinon, les problèmes de validation sont affichés sur la console.

Nous avons développé un flux de travail rapide pour évaluer les saisies utilisateur et générer 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 de code clair, lisible et maintenable. Pour en savoir plus sur les capacités d'IronPDF, consultez la page de documentation. Ci-dessous le fragment de code d'exemple.

using IronPdf;
using System;
using System.Linq;
using System.Text;
using Flunt.Validations;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // StringBuilder for HTML content
            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!");
                sb.Append("<p>Person is valid!</p>");
            }
            else
            {
                sb.Append("<p>Validation failed: </p>");
                foreach (var notification in contract.Notifications)
                {
                    sb.Append($"- {notification.Key}: {notification.Message}<br>");
                }
            }

            var renderer = new HtmlToPdf();
            // Set HTML content for the page
            var pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString());
            // Save the document
            pdfDocument.SaveAs("output.pdf");
            // Dispose the renderer 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 for HTML content
            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!");
                sb.Append("<p>Person is valid!</p>");
            }
            else
            {
                sb.Append("<p>Validation failed: </p>");
                foreach (var notification in contract.Notifications)
                {
                    sb.Append($"- {notification.Key}: {notification.Message}<br>");
                }
            }

            var renderer = new HtmlToPdf();
            // Set HTML content for the page
            var pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString());
            // Save the document
            pdfDocument.SaveAs("output.pdf");
            // Dispose the renderer 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)
			' StringBuilder for HTML content
			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!")
				sb.Append("<p>Person is valid!</p>")
			Else
				sb.Append("<p>Validation failed: </p>")
				For Each notification In contract.Notifications
					sb.Append($"- {notification.Key}: {notification.Message}<br>")
				Next notification
			End If

			Dim renderer = New HtmlToPdf()
			' Set HTML content for the page
			Dim pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString())
			' Save the document
			pdfDocument.SaveAs("output.pdf")
			' Dispose the renderer 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

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

Conclusion

IronPDF et Flunt sont deux puissantes bibliothèques C# qui fonctionnent bien ensemble pour simplifier les flux de travail de création de documents et de validation des données. Avec les fonctionnalités sophistiquées de production de PDF d'IronPDF et les puissantes capacités de validation de Flunt, les développeurs peuvent construire des solutions fiables, efficaces et de haute qualité pour une variété d'applications. Flunt et IronPDF équipent 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 bibliothèque sont inclus dans le pack Lite $799. IronPDF fournit des détails de licence gratuits d'IronPDF pour plus d'informations concernant le coût et les exigences de licence. Pour des informations supplémentaires sur les bibliothèques d'Iron Software, visitez le site officiel d'Iron Software.