Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de IronPDF
  4. Validation Fluente
UTILISATION DE IRONPDF

Comment utiliser la validation Fluent avec IronPDF en C#

Curtis Chau
Curtis Chau
Mis à jour:

Qu'est-ce que la validation fluide ?

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.

Comprendre la validation fluide

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.

  1. Validateurs: Les validateurs sont des classes qui encapsulent la logique de validation. Ils sont généralement créés en hébergeant la classe de base AbstractValidator<T>.
  2. Règles: Une règle est une condition de validation qu'une propriété doit respecter. Les règles sont définies à l'aide de la méthode RuleFor dans une classe de validateur.
  3. Échecs de validation : Si une règle échoue, Fluent Validation crée un objet ValidationFailure qui contient des détails sur l'erreur, y compris le nom de la propriété et le message d'erreur.

Qu'est-ce que IronPDF?

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.

Utiliser la validation fluide avec IronPDF

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.

Configuration du projet

Pour commencer, créons une nouvelle application console dans Visual Studio ou votre environnement de développement préféré.

  1. Ouvrez Visual Studio et allez à Fichier > Nouveau > Projet.
  2. Sélectionnez "Application Console (ASP.NET Core)" comme modèle de projet et donnez un nom à votre projet.

Comment utiliser la validation fluide avec IronPDF en C#, Figure 1 : Créer une nouvelle application console Créer une nouvelle application console

  1. Cliquez sur le bouton Suivant et configurez votre projet en le nommant et en sélectionnant l'emplacement du référentiel.

Comment utiliser la validation fluide avec IronPDF en C#, Figure 2 : Configurer la nouvelle application Configurer la nouvelle application

  1. Cliquez sur le bouton Suivant et sélectionnez le .NET Framework. Le dernier .NET Framework (7) est recommandé.

Comment utiliser la validation fluide avec IronPDF en C#, Figure 3 : Sélection du .NET Framework Sélection du .NET Framework

  1. Cliquez sur le bouton Créer pour créer le projet.

Installer les packages requis

Une fois le projet créé, ajoutez les packages NuGet nécessaires pour Fluent Validation et IronPDF.

  1. Cliquez avec le bouton droit sur le projet dans l'Explorateur de solutions et sélectionnez "Gérer les packages NuGet".
  2. Recherchez "FluentValidation" et cliquez sur "Installer" pour ajouter le package à votre projet.

Comment utiliser la validation fluide avec IronPDF en C#, Figure 4 : Installer le package FluentValidation dans l'UI du gestionnaire de packages NuGet Installer le package FluentValidation dans l'UI du gestionnaire de packages NuGet

  1. 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 :

Install-Package IronPdf

Comment utiliser la validation fluide avec IronPDF en C#, Figure 5 : Installer le package IronPdf dans la Console du gestionnaire de packages 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.

Définir le contenu PDF

Dans cet exemple, une simple facture PDF sera créée à 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; }
}
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 Class
$vbLabelText   $csharpLabel

Dans 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 de la facture PDF. 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 'Price'. La méthode RenderHtml génère le balisage HTML pour la facture basé sur le 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.

Créer des règles de validation

Pour créer des règles de validation pour la classe InvoiceContent, créez une classe 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.");
    }
}
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 Class
$vbLabelText   $csharpLabel

Dans le code source, la classe InvoiceContentValidator est définie, qui hérite de AbstractValidator<InvoiceContent>. Dans le constructeur de la classe 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 en utilisant IronPDF.

Générer le 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.");
        }
    }
}
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)(ByVal 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)(ByVal content As T) As IValidator(Of T)
		If TypeOf content Is InvoiceContent Then
			Return DirectCast(New InvoiceContentValidator(), IValidator(Of T))
		Else
			Throw New NotSupportedException("Unsupported content type.")
		End If
	End Function
End Class
$vbLabelText   $csharpLabel

La classe PdfService fournit une méthode GeneratePdf. Cette méthode prend un objet PdfContent en entrée et génère le document PDF basé sur le contenu validé.

Tout d'abord, elle récupère le validateur approprié pour le contenu en appelant la méthode GetValidatorForContent, qui vérifie le type de contenu et renvoie le validateur correspondant. Dans notre cas, nous supportons InvoiceContent et utilisons le InvoiceContentValidator.

Ensuite, le contenu est validé à l'aide du validateur en appelant sa méthode Validate. Le résultat de la validation est enregistré dans un objet ValidationResult.

Si la validation échoue (!validationResult.IsValid), une FluentValidation.ValidationException est déclenchée avec les erreurs de validation. Sinon, le PDF est généré en utilisant 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.

Gérer les erreurs de validation

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 toutes les exceptions 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);
        }
    }
}
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 Class
$vbLabelText   $csharpLabel

Dans le code ci-dessus, des blocs try-catch sont utilisés pour intercepter toutes les exceptions pouvant survenir. Si une exception est interceptée, un message d'erreur sera affiché à l'utilisateur à l'aide de 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.

Tester l'application

Dans l'exemple de code, il y a trois scénarios à tester :

  1. Nom de client vide : Laissez le nom du client vide pour déclencher une erreur de validation.
  2. Articles de facture vides : Fournissez une liste vide d'articles de facture pour déclencher une erreur de validation.
  3. Génération réussie : Fournissez un contenu valide pour générer le PDF avec succès.

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!

Comment utiliser la validation fluide avec IronPDF en C#, Figure 6 : L'erreur de sortie dans la Console L'erreur de sortie dans la Console

Comment utiliser la validation fluide avec IronPDF en C#, Figure 7 : Le fichier PDF de sortie 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.

Conclusion

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.

Questions Fréquemment Posées

Comment puis-je intégrer Fluent Validation avec la génération de PDF en C# ?

Pour intégrer Fluent Validation avec la génération de PDF en C#, vous pouvez configurer une Application Console dans Visual Studio, installer les packages FluentValidation et IronPDF via NuGet, et définir votre logique de validation de modèle en utilisant Fluent Validation tout en générant des PDFs avec IronPDF.

Quelles étapes sont impliquées dans la configuration d'un projet pour la génération et la validation de PDF ?

Pour configurer un projet, créez une nouvelle Application Console dans Visual Studio, installez les packages IronPDF et FluentValidation via NuGet, puis définissez votre contenu PDF et les règles de validation en utilisant les bibliothèques respectives.

Comment puis-je générer un PDF à partir de contenu HTML en utilisant une bibliothèque .NET ?

Vous pouvez générer un PDF à partir de contenu HTML en utilisant la méthode RenderHtmlAsPdf d'IronPDF, qui vous permet de convertir des chaînes ou fichiers HTML en PDFs de haute qualité.

Quel est le but de la classe PdfService dans le tutoriel ?

La classe PdfService dans le tutoriel est conçue pour gérer la génération de PDF en validant d'abord le contenu en utilisant Fluent Validation. En cas de validation réussie, elle utilise les méthodes ChromePdfRenderer et RenderHtmlAsPdf d'IronPDF pour créer le PDF.

Comment les règles de validation sont-elles définies en utilisant Fluent Validation ?

Les règles de validation dans Fluent Validation sont définies en créant une classe de validateur qui hérite de AbstractValidator. Dans cette classe, la méthode RuleFor est utilisée pour spécifier des conditions pour chaque propriété, permettant des messages d'erreur personnalisés et l'enchaînement des règles.

Que se passe-t-il si la validation échoue pendant la génération de PDF ?

Si la validation échoue, Fluent Validation lance une ValidationException qui contient des informations détaillées sur les erreurs de validation, ce qui peut être utilisé pour informer l'utilisateur de ce qui n'a pas fonctionné.

Puis-je utiliser Fluent Validation pour la validation d'objets complexes ?

Oui, Fluent Validation prend en charge la validation d'objets complexes grâce à l'utilisation de validateurs enfants, vous permettant de valider des propriétés imbriquées et des collections au sein de votre modèle.

Comment puis-je personnaliser les messages d'erreur dans Fluent Validation ?

Les messages d'erreur personnalisés dans Fluent Validation peuvent être définis en utilisant la méthode WithMessage pour chaque règle de validation spécifiée avec RuleFor.

Existe-t-il une version d'essai disponible pour la bibliothèque de génération de PDF ?

Oui, IronPDF propose une version d'essai gratuite pour permettre aux développeurs de tester les capacités de la bibliothèque, avec des options de licence à partir de 499 $ par développeur.

IronPDF est-il entièrement compatible avec .NET 10 ?

Oui. IronPDF est entièrement compatible avec .NET 10 et prend en charge les plateformes Windows, Linux et macOS dans différents types de projets (console, web, bureau, Blazor, etc.). Il fonctionne immédiatement avec la dernière version du runtime, sans aucune manipulation complexe.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

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 ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit