Wie man Fluent Validation mit IronPDF in C# verwendet

Verständnis von Fluent Validation

Fluent Validation ist eine Open-Source-Bibliothek für .NET, die es einfach macht, Validierungsregeln für Ihre Modellklassen zu erstellen.

1. Validatoren: Validatoren sind Klassen, die die Validierungslogik kapseln. Sie werden typischerweise erstellt, indem sie von der AbstractValidator<T>-Basisklasse erben.
2. Regeln: Eine Regel ist eine Validierungsbedingung, die eine Eigenschaft erfüllen muss. Regeln werden mit der RuleFor-Methode in einer Validatorklasse definiert.
3. Validierungsfehler: Wenn eine Regel fehlschlägt, erstellt Fluent Validation ein ValidationFailure-Objekt, das Details über den Fehler enthält, einschließlich des Eigenschaftsnames und der Fehlermeldung.

Einrichten des Projekts

Um zu beginnen, erstellen wir eine neue Konsolenanwendung in Visual Studio oder Ihrer bevorzugten Entwicklungsumgebung.

1. Öffnen Sie Visual Studio und gehen Sie zu Datei > Neu > Projekt.
2. Wählen Sie "Konsolen-App (ASP.NET Core)" als Projekttemplate aus und geben Sie einen Namen für Ihr Projekt an.

Erstellen einer neuen Konsolenanwendung

3. Klicken Sie auf die Schaltfläche Weiter und konfigurieren Sie Ihr Projekt, indem Sie es benennen und den Ablageort auswählen.

Konfigurieren Sie die neue Anwendung

4. Klicken Sie auf die Schaltfläche Weiter und wählen Sie die .NET Framework-Version aus. Das neueste .NET Framework (7) wird empfohlen.

Auswahl des .NET Frameworks

5. Klicken Sie auf die Schaltfläche Erstellen, um das Projekt zu erstellen.

Erforderliche Pakete installieren

Sobald das Projekt erstellt ist, fügen Sie die notwendigen NuGet-Pakete für Fluent Validation und IronPDF hinzu.

1. Klicken Sie mit der rechten Maustaste auf das Projekt im Projektmappen-Explorer und wählen Sie "NuGet-Pakete verwalten".
2. Suchen Sie nach "FluentValidation" und klicken Sie auf "Installieren", um das Paket zu Ihrem Projekt hinzuzufügen.

Installieren Sie das FluentValidation-Paket in der NuGet-Paket-Manager-Benutzeroberfläche

3. Auf ähnliche Weise suchen Sie nach "IronPDF - Leistungsstarke .NET PDF-Bibliothek" und installieren Sie das IronPDF-Paket.

Alternativ können Sie IronPDF auch über die NuGet-Paket-Manager-Konsole mit folgendem Befehl installieren:

Install-Package IronPdf

Installieren Sie das IronPdf-Paket in der Paket-Manager-Konsole

Mit dem eingerichteten Projekt und den installierten benötigten Paketen kommen wir nun zur Definition der PDF-Inhaltsklasse.

Definition des PDF-Inhalts

In diesem Beispiel wird ein einfaches Rechnungs-PDF aus den HTML-Codes in zwei Klassen erstellt: InvoiceContent und 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

Im obigen Code ist eine abstrakte PdfContent-Klasse mit einer abstrakten Methode namens RenderHtml definiert. Die InvoiceContent-Klasse erweitert PdfContent und stellt den Inhalt des Rechnungs-PDFs dar. Sie besitzt Eigenschaften für den Kundenname, die Adresse und eine Liste von Rechnungsposten. Die InvoiceItem-Klasse enthält zwei Eigenschaften: 'Beschreibung' und 'Preis'. Die RenderHtml-Methode generiert das HTML-Markup für die Rechnung basierend auf dem Inhalt.

Jetzt, da der PDF-Inhalt definiert ist, gehen wir weiter zur Erstellung von Validierungsregeln mit Fluent Validation.

Erstellen von Validierungsregeln

Um Validierungsregeln für die InvoiceContent-Klasse zu erstellen, erstellen Sie eine Validatorklasse namens InvoiceContentValidator. Diese Klasse erbt von AbstractValidator<InvoiceContent>, das von FluentValidation bereitgestellt wird.

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

Im Quellcode ist die InvoiceContentValidator-Klasse definiert, die von AbstractValidator<InvoiceContent> erbt. Im Konstruktor der Validatorklasse definiert die RuleFor-Methode Validierungsregeln für jede Eigenschaft der InvoiceContent-Klasse.

Zum Beispiel: RuleFor(content => content.CustomerName) legt fest, dass der Kundenname nicht leer sein darf. Ähnliche Validierungsregeln werden für die Adress- und Rechnungsposten-Eigenschaften definiert.

Die RuleForEach-Methode iteriert über jedes Element in der InvoiceItems-Liste und wendet den InvoiceItemValidator an. Die InvoiceItemValidator-Klasse enthält Validierungsregeln für die InvoiceItem-Klasse.

Mit diesen Validierungsregeln gehen wir nun weiter zur PDF-Erstellung mit IronPDF.

Erstellen eines PDFs mit IronPDF

IronPDF - Erstellen und Bearbeiten von PDF-Dokumenten ist eine beliebte .NET-Bibliothek zum Erstellen und Verarbeiten von PDF-Dokumenten. IronPDF wird verwendet, um das PDF basierend auf dem validierten Rechnungsinhalt zu erstellen.

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

Die PdfService-Klasse bietet eine GeneratePdf-Methode. Diese Methode nimmt ein PdfContent-Objekt als Eingabe und generiert das PDF-Dokument basierend auf dem validierten Inhalt.

Zuerst wird der entsprechende Validator für den Inhalt durch Aufruf der GetValidatorForContent-Methode abgerufen, die den Inhaltstyp überprüft und den entsprechenden Validator zurückgibt. In unserem Fall unterstützen wir InvoiceContent und verwenden den InvoiceContentValidator.

Als Nächstes wird der Inhalt mithilfe des Validators durch Aufruf seiner Validate-Methode validiert. Das Validierungsergebnis wird in einem ValidationResult-Objekt gespeichert.

Wenn die Validierung fehlschlägt (!validationResult.IsValid), wird eine FluentValidation.ValidationException mit den Validierungsfehlern ausgelöst. Andernfalls wird das PDF mit IronPDF generiert.

Eine Instanz von ChromePdfRenderer wird erstellt, um den HTML-Inhalt als PDF zu rendern. Die RenderHtmlAsPdf-Methode wird auf dem renderer-Objekt aufgerufen, wobei das von der content.RenderHtml-Methode generierte HTML übergeben wird, um das PDF-Dokument zu erstellen.

Nun, da wir die PDF-Erstellungslogik definiert haben, behandeln wir eventuelle Validierungsfehler.

Behandlung von Validierungsfehlern

Bei einem Validierungsfehler möchten wir eine Fehlermeldung anzeigen und diesen Fehler auf elegante Weise behandeln. Lassen Sie uns die Main-Methode der Program-Klasse ändern, um eventuell auftretende Ausnahmen zu handhaben und dem Benutzer sinnvolle Meldungen anzuzeigen.

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

Im obigen Code werden try-catch-Blöcke verwendet, um etwaige Ausnahmen zu erfassen, die auftreten können. Falls eine Ausnahme erfasst wird, wird dem Benutzer eine Fehlermeldung mit Console.WriteLine angezeigt.

Testen wir nun diese Anwendung mit verschiedenen Szenarien, um die PDF-Erstellung und die Validierungsregeln zu validieren.

Testen der Anwendung

Im Codebeispiel gibt es drei Szenarien zu testen:

1. Leerer Kundenname: Lassen Sie den Kundennamen leer, um einen Validierungsfehler auszulösen.
2. Leere Rechnungsposten: Geben Sie eine leere Liste von Rechnungsposten an, um einen Validierungsfehler auszulösen.
3. Erfolgreiche Erstellung: Geben Sie gültige Inhalte an, um das PDF erfolgreich zu generieren.

Führen Sie die Anwendung aus und beobachten Sie die Ausgabe in der Konsole.

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!

Der Ausgabefehler in der Konsole

Die Ausgabe-PDF-Datei

Wie erwartet werden Validierungsfehler für die ersten beiden Szenarien angezeigt und eine Erfolgsmeldung für das dritte Szenario.