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 durch Vererbung von der Basisklasse AbstractValidator<t> erstellt.
2. Regeln: Eine Regel ist eine Validierungsbedingung, die eine Eigenschaft erfüllen muss. Regeln werden mithilfe der Methode RuleFor in einer Validatorklasse definiert.
3. Validierungsfehler: Wenn eine Regel fehlschlägt, erstellt Fluent Validation ein ValidationFailure-Objekt, das Details zum Fehler enthält, einschließlich des Eigenschaftsnamens 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 Sie eine neue 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.

   .NET Framework-Auswahl

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 aus den HTML-Codes in zwei Klassen eine einfache PDF-Rechnung 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; }
}

Im obigen Code wird eine abstrakte Klasse PdfContent mit einer abstrakten Methode namens RenderHtml definiert. Die Klasse InvoiceContent erweitert PdfContent und repräsentiert den Inhalt der PDF-Rechnung. Sie besitzt Eigenschaften für den Kundenname, die Adresse und eine Liste von Rechnungsposten. Die Klasse InvoiceItem enthält zwei Eigenschaften: 'Description' und 'Price'. Die Methode RenderHtml 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 Klasse InvoiceContent zu erstellen, erstellen Sie eine Validatorklasse namens InvoiceContentValidator. Diese Klasse erbt von AbstractValidator<InvoiceContent>, die 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.");
    }
}

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

Beispielsweise gibt RuleFor(content => content.CustomerName) an, dass der Kundenname nicht leer sein darf. Ähnliche Validierungsregeln werden für die Adress- und Rechnungsposten-Eigenschaften definiert.

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

Mit diesen Validierungsregeln im Hinterkopf, lassen Sie uns mit der Generierung der PDF mit IronPDF fortfahren.

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.");
        }
    }
}

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

Zunächst wird der passende Validator für den Inhalt durch Aufruf der Methode GetValidatorForContent abgerufen, welche den Inhaltstyp prüft und den entsprechenden Validator zurückgibt. In unserem Fall unterstützen wir InvoiceContent und verwenden InvoiceContentValidator.

Anschließend wird der Inhalt mithilfe des Validators validiert, indem dessen Methode Validate aufgerufen wird. Das Validierungsergebnis wird in einem ValidationResult-Objekt gespeichert.

Wenn die Validierung fehlschlägt (!validationResult.IsValid), wird ein FluentValidation.ValidationException zusammen mit den Validierungsfehlern ausgegeben. Andernfalls wird das PDF mit IronPDF generiert.

Eine Instanz von ChromePdfRenderer wird erstellt, um den HTML-Inhalt als PDF zu rendern. Die Methode RenderHtmlAsPdf wird für das Objekt renderer aufgerufen und übergibt den von der Methode content.RenderHtml generierten HTML-Code, wodurch das PDF-Dokument erzeugt wird.

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. Wir modifizieren die Methode Main der Klasse Program, um alle Ausnahmen abzufangen und dem Benutzer aussagekräftige 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);
        }
    }
}

Im obigen Code werden try-catch Blöcke verwendet, um eventuell auftretende Ausnahmen abzufangen. Wenn eine Ausnahme auftritt, wird dem Benutzer eine Fehlermeldung mit dem Code 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.