FluentValidation est une bibliothèque de validation .NET qui aide à créer des règles de validation fortement typées. Il utilise une interface fluide et des expressions lambda, rendant le code plus lisible et maintenable. Au lieu d'utiliser des annotations de données ou une validation manuelle dans vos classes de modèle, vous pouvez utiliser la validation fluide pour créer une classe distincte pour votre logique de validation.
La validation fluide apporte plus de flexibilité au jeu de validation. Avec des validateurs intégrés pour les scénarios courants, la possibilité de créer des validations personnalisées et un moyen simple de chaîner les règles de validation, la validation fluide est un outil puissant dans l'outil .NET Core.
Fluent Validation est une bibliothèque open-source pour .NET qui facilite la création de règles de validation pour vos classes de modèle.
AbstractValidator<t>.RuleFor dans une classe de validateur.ValidationFailure qui contient des détails sur l'erreur, y compris le nom de la propriété et le message d'erreur.IronPDF - Convertir HTML en PDF en C# est une bibliothèque .NET puissante qui vous permet de générer des documents PDF à partir de contenu HTML. Que vous ayez besoin de créer des factures, des rapports ou tout autre type de document, IronPDF propose une solution facile à utiliser. Il s'intègre parfaitement à vos applications ASP.NET Core, vous permettant de générer des fichiers PDF de haute qualité avec seulement quelques lignes de code.
Maintenant que nous comprenons ce que sont la validation fluide et IronPDF, voyons comment ils peuvent être utilisés ensemble. Ce tutoriel aidera à construire un générateur de factures, où le contenu de la facture sera validé en utilisant FluentValidation dans ASP.NET Core avant de générer le PDF avec IronPDF.
Pour commencer, créons une nouvelle application console dans Visual Studio ou votre environnement de développement préféré.
Ouvrez Visual Studio et allez à Fichier > Nouveau > Projet.
Sélectionnez "Application Console (ASP.NET Core)" comme modèle de projet et donnez un nom à votre projet.
Créer une nouvelle application console
Cliquez sur le bouton Suivant et configurez votre projet en le nommant et en sélectionnant l'emplacement du référentiel.
Configurer la nouvelle application
Cliquez sur le bouton Suivant et sélectionnez le .NET Framework. Le dernier .NET Framework (7) est recommandé.
Sélection du .NET Framework
Cliquez sur le bouton Créer pour créer le projet.
Une fois le projet créé, ajoutez les packages NuGet nécessaires pour Fluent Validation et IronPDF.
Cliquez avec le bouton droit sur le projet dans l'Explorateur de solutions et sélectionnez "Gérer les packages NuGet".
Recherchez "FluentValidation" et cliquez sur "Installer" pour ajouter le package à votre projet.
Installer le package FluentValidation dans l'UI du gestionnaire de packages NuGet
De même, cherchez "IronPDF - Puissante bibliothèque PDF .NET" et installez le package IronPDF.
Alternativement, vous pouvez installer IronPDF en utilisant la Console du gestionnaire de packages NuGet avec la commande suivante :
Installer le package IronPDF dans la console du gestionnaire de packages
Une fois que le projet est configuré et que les packages requis sont installés, passons à la définition de la classe de contenu PDF.
Dans cet exemple, un simple PDF de facture sera créé à partir des codes HTML dans deux classes : InvoiceContent et InvoiceItem.
using System.Collections.Generic;
using System.Linq;
public abstract class PdfContent
{
// Abstract method to generate the HTML string
public abstract string RenderHtml();
}
public class InvoiceContent : PdfContent
{
public string CustomerName { get; set; }
public string Address { get; set; }
public List<InvoiceItem> InvoiceItems { get; set; }
// Constructs the HTML representation of the invoice
public override string RenderHtml()
{
string invoiceItemsHtml = string.Join("", InvoiceItems.Select(item => $"<li>{item.Description}: {item.Price}</li>"));
return $"<h1>Invoice for {CustomerName}</h1><p>{Address}</p><ul>{invoiceItemsHtml}</ul>";
}
}
public class InvoiceItem
{
public string Description { get; set; }
public decimal Price { get; set; }
}Imports System.Collections.Generic
Imports System.Linq
Public MustInherit Class PdfContent
' Abstract method to generate the HTML string
Public MustOverride Function RenderHtml() As String
End Class
Public Class InvoiceContent
Inherits PdfContent
Public Property CustomerName() As String
Public Property Address() As String
Public Property InvoiceItems() As List(Of InvoiceItem)
' Constructs the HTML representation of the invoice
Public Overrides Function RenderHtml() As String
Dim invoiceItemsHtml As String = String.Join("", InvoiceItems.Select(Function(item) $"<li>{item.Description}: {item.Price}</li>"))
Return $"<h1>Invoice for {CustomerName}</h1><p>{Address}</p><ul>{invoiceItemsHtml}</ul>"
End Function
End Class
Public Class InvoiceItem
Public Property Description() As String
Public Property Price() As Decimal
End ClassDans le code ci-dessus, une classe abstraite PdfContent est définie avec une méthode abstraite appelée RenderHtml. La classe InvoiceContent étend PdfContent et représente le contenu du PDF de la facture. Elle a des propriétés pour le nom du client, l'adresse et une liste d'articles de facture. La classe InvoiceItem contient deux propriétés : 'Description' et 'Prix'. La méthode RenderHtml génère le balisage HTML pour la facture en fonction du contenu.
Maintenant que le contenu du PDF est défini, passons à la création des règles de validation à l'aide de la validation fluide.
Pour construire des règles de validation pour la classe InvoiceContent, créez une classe de validateur appelée InvoiceContentValidator. Cette classe héritera de AbstractValidator<InvoiceContent>, qui est fourni par FluentValidation.
using FluentValidation;
public class InvoiceContentValidator : AbstractValidator<InvoiceContent>
{
public InvoiceContentValidator()
{
RuleFor(content => content.CustomerName).NotEmpty().WithMessage("Customer name is required.");
RuleFor(content => content.Address).NotEmpty().WithMessage("Address is required.");
RuleFor(content => content.InvoiceItems).NotEmpty().WithMessage("At least one invoice item is required.");
RuleForEach(content => content.InvoiceItems).SetValidator(new InvoiceItemValidator());
}
}
public class InvoiceItemValidator : AbstractValidator<InvoiceItem>
{
public InvoiceItemValidator()
{
RuleFor(item => item.Description).NotEmpty().WithMessage("Description is required.");
RuleFor(item => item.Price).GreaterThanOrEqualTo(0).WithMessage("Price must be greater than or equal to 0.");
}
}Imports FluentValidation
Public Class InvoiceContentValidator
Inherits AbstractValidator(Of InvoiceContent)
Public Sub New()
RuleFor(Function(content) content.CustomerName).NotEmpty().WithMessage("Customer name is required.")
RuleFor(Function(content) content.Address).NotEmpty().WithMessage("Address is required.")
RuleFor(Function(content) content.InvoiceItems).NotEmpty().WithMessage("At least one invoice item is required.")
RuleForEach(Function(content) content.InvoiceItems).SetValidator(New InvoiceItemValidator())
End Sub
End Class
Public Class InvoiceItemValidator
Inherits AbstractValidator(Of InvoiceItem)
Public Sub New()
RuleFor(Function(item) item.Description).NotEmpty().WithMessage("Description is required.")
RuleFor(Function(item) item.Price).GreaterThanOrEqualTo(0).WithMessage("Price must be greater than or equal to 0.")
End Sub
End ClassDans le code source, la classe InvoiceContentValidator est définie, qui hérite de AbstractValidator<InvoiceContent>. À l'intérieur du constructeur de la classe de validateur, la méthode RuleFor définit des règles de validation pour chaque propriété de la classe InvoiceContent.
Par exemple, RuleFor(content => content.CustomerName) spécifie que le nom du client ne doit pas être vide. De même, les règles de validation sont définies pour les propriétés de l'adresse et des articles de facture.
La méthode RuleForEach itère sur chaque élément de la liste InvoiceItems et applique le InvoiceItemValidator. La classe InvoiceItemValidator contient des règles de validation pour la classe InvoiceItem.
Avec ces règles de validation en place, passons à la génération du PDF avec IronPDF.
IronPDF - Générer et modifier des documents PDF est une bibliothèque .NET populaire pour la création et la manipulation de documents PDF. IronPDF sera utilisé pour générer le PDF basé sur le contenu de la facture validé.
using IronPdf;
using FluentValidation;
public class PdfService
{
// Generates a PDF document for the provided content
public PdfDocument GeneratePdf<t>(T content) where T : PdfContent
{
// Validate the content using the appropriate validator
var validator = GetValidatorForContent(content);
var validationResult = validator.Validate(content);
// Check if validation is successful
if (!validationResult.IsValid)
{
throw new FluentValidation.ValidationException(validationResult.Errors);
}
// Generate the PDF using IronPDF
var renderer = new ChromePdfRenderer();
return renderer.RenderHtmlAsPdf(content.RenderHtml());
}
// Retrieves the appropriate validator for the content
private IValidator<t> GetValidatorForContent<t>(T content) where T : PdfContent
{
if (content is InvoiceContent)
{
return (IValidator<t>)new InvoiceContentValidator();
}
else
{
throw new NotSupportedException("Unsupported content type.");
}
}
}Imports IronPdf
Imports FluentValidation
Public Class PdfService
' Generates a PDF document for the provided content
Public Function GeneratePdf(Of T As PdfContent)(content As T) As PdfDocument
' Validate the content using the appropriate validator
Dim validator = GetValidatorForContent(content)
Dim validationResult = validator.Validate(content)
' Check if validation is successful
If Not validationResult.IsValid Then
Throw New FluentValidation.ValidationException(validationResult.Errors)
End If
' Generate the PDF using IronPDF
Dim renderer = New ChromePdfRenderer()
Return renderer.RenderHtmlAsPdf(content.RenderHtml())
End Function
' Retrieves the appropriate validator for the content
Private Function GetValidatorForContent(Of T As PdfContent)(content As T) As IValidator(Of T)
If TypeOf content Is InvoiceContent Then
Return CType(New InvoiceContentValidator(), IValidator(Of T))
Else
Throw New NotSupportedException("Unsupported content type.")
End If
End Function
End ClassLa classe PdfService fournit une méthode GeneratePdf. Cette méthode prend un objet PdfContent en entrée et génère le document PDF en fonction du contenu validé.
Tout d'abord, il récupère le validateur approprié pour le contenu en appelant la méthode GetValidatorForContent, qui vérifie le type de contenu et retourne le validateur correspondant. Dans notre cas, nous supportons InvoiceContent et utilisons le InvoiceContentValidator.
Ensuite, le contenu est validé en utilisant le validateur en appelant sa méthode Validate. Le résultat de la validation est stocké dans un objet ValidationResult.
Si la validation échoue (!validationResult.IsValid), un FluentValidation.ValidationException est lancé avec les erreurs de validation. Sinon, le PDF est généré avec IronPDF.
Une instance de ChromePdfRenderer est créée pour rendre le contenu HTML en PDF. La méthode RenderHtmlAsPdf est appelée sur l'objet renderer, en passant le HTML généré par la méthode content.RenderHtml, générant le document PDF.
Maintenant que nous avons défini la logique de génération de PDF, abordons les erreurs de validation qui peuvent survenir.
Lorsqu'une erreur de validation survient, nous voulons afficher un message d'erreur et la gérer avec grâce. Modifions la méthode Main de la classe Program pour gérer les exceptions éventuelles et afficher des messages significatifs à l'utilisateur.
using System;
using System.Collections.Generic;
public class Program
{
static void Main(string[] args)
{
var pdfService = new PdfService();
// Test 1: Empty Customer Name
try
{
var invoiceContent = new InvoiceContent
{
CustomerName = "",
Address = "123 Main St, Anytown, USA",
InvoiceItems = new List<InvoiceItem> {
new InvoiceItem { Description = "Item 1", Price = 19.99M },
new InvoiceItem { Description = "Item 2", Price = 29.99M }
}
};
var pdfDocument = pdfService.GeneratePdf(invoiceContent);
pdfDocument.SaveAs("C:\\TestInvoice.pdf");
Console.WriteLine("PDF generated successfully!");
}
catch (Exception ex)
{
Console.WriteLine("Error generating PDF: " + ex.Message);
}
// Test 2: Empty InvoiceItems
try
{
var invoiceContent = new InvoiceContent
{
CustomerName = "John Doe",
Address = "123 Main St, Anytown, USA",
InvoiceItems = new List<InvoiceItem>() // Empty list
};
var pdfDocument = pdfService.GeneratePdf(invoiceContent);
pdfDocument.SaveAs("C:\\TestInvoice.pdf");
Console.WriteLine("PDF generated successfully!");
}
catch (Exception ex)
{
Console.WriteLine("Error generating PDF: " + ex.Message);
}
// Successful generation
try
{
var invoiceContent = new InvoiceContent
{
CustomerName = "John Doe",
Address = "123 Main St, Anytown, USA",
InvoiceItems = new List<InvoiceItem> {
new InvoiceItem { Description = "Item 1", Price = 19.99M },
new InvoiceItem { Description = "Item 2", Price = 29.99M }
}
};
var pdfDocument = pdfService.GeneratePdf(invoiceContent);
pdfDocument.SaveAs("C:\\TestInvoice.pdf");
Console.WriteLine("PDF generated successfully!");
}
catch (Exception ex)
{
Console.WriteLine("Error generating PDF: " + ex.Message);
}
}
}Imports System
Imports System.Collections.Generic
Public Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfService As New PdfService()
' Test 1: Empty Customer Name
Try
Dim invoiceContent As New InvoiceContent With {
.CustomerName = "",
.Address = "123 Main St, Anytown, USA",
.InvoiceItems = New List(Of InvoiceItem) From {
New InvoiceItem With {
.Description = "Item 1",
.Price = 19.99D
},
New InvoiceItem With {
.Description = "Item 2",
.Price = 29.99D
}
}
}
Dim pdfDocument = pdfService.GeneratePdf(invoiceContent)
pdfDocument.SaveAs("C:\TestInvoice.pdf")
Console.WriteLine("PDF generated successfully!")
Catch ex As Exception
Console.WriteLine("Error generating PDF: " & ex.Message)
End Try
' Test 2: Empty InvoiceItems
Try
Dim invoiceContent As New InvoiceContent With {
.CustomerName = "John Doe",
.Address = "123 Main St, Anytown, USA",
.InvoiceItems = New List(Of InvoiceItem)()
}
Dim pdfDocument = pdfService.GeneratePdf(invoiceContent)
pdfDocument.SaveAs("C:\TestInvoice.pdf")
Console.WriteLine("PDF generated successfully!")
Catch ex As Exception
Console.WriteLine("Error generating PDF: " & ex.Message)
End Try
' Successful generation
Try
Dim invoiceContent As New InvoiceContent With {
.CustomerName = "John Doe",
.Address = "123 Main St, Anytown, USA",
.InvoiceItems = New List(Of InvoiceItem) From {
New InvoiceItem With {
.Description = "Item 1",
.Price = 19.99D
},
New InvoiceItem With {
.Description = "Item 2",
.Price = 29.99D
}
}
}
Dim pdfDocument = pdfService.GeneratePdf(invoiceContent)
pdfDocument.SaveAs("C:\TestInvoice.pdf")
Console.WriteLine("PDF generated successfully!")
Catch ex As Exception
Console.WriteLine("Error generating PDF: " & ex.Message)
End Try
End Sub
End ClassDans le code ci-dessus, des blocs try-catch sont utilisés pour capturer toutes les exceptions pouvant survenir. Si une exception est capturée, un message d'erreur sera affiché à l'utilisateur en utilisant Console.WriteLine.
Maintenant, testons cette application avec différents scénarios pour valider la génération de PDF et les règles de validation.
Dans l'exemple de code, il y a trois scénarios à tester :
Exécutez l'application et observez la sortie dans la console.
Error generating PDF: Validation failed:
-- CustomerName: Customer name is required. Severity: Error
Error generating PDF: Validation failed:
-- InvoiceItems: At least one invoice item is required. Severity: Error
PDF generated successfully!
L'erreur de sortie dans la Console
Le fichier PDF de sortie
Comme prévu, des erreurs de validation sont affichées pour les deux premiers scénarios et un message de succès pour le troisième.
Ce tutoriel a exploré Fluent Validation et comment l'utiliser avec IronPDF pour générer des documents PDF. En commençant par configurer une application console et en définissant la classe de contenu PDF. Puis, a créé des règles de validation en utilisant Fluent Validation et a testé la génération de PDF avec différents scénarios.
Fluent Validation offre une approche flexible et facile à utiliser pour la validation d'objets dans les applications .NET. Elle vous permet de définir des règles de validation de manière fortement typée, de personnaliser les messages d'erreur et de gérer les erreurs de validation avec grâce.
IronPDF Free Trial & Licensing Information propose un essai gratuit, et la licence commence à partir de 499 $ par développeur.
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
