Verwendung der fließenden Validierung mit IronPDF in C#

Was ist Fluent Validation?

FluentValidierung ist eine .NET-Validierungsbibliothek, die bei der Erstellung stark typisierter Validierungsregeln hilft. Dies geschieht durch die Bereitstellung einer fließenden Schnittstelle und von Lambda-Ausdrücken, wodurch der Code besser lesbar und wartbar wird. Anstatt Datenkommentare oder manuelle Validierung in Ihren Modellklassen zu verwenden, können Sie mit Fluent Validation eine separate Klasse für Ihre Validierungslogik erstellen.

Fluent Validation bringt mehr Flexibilität ins Validierungsspiel. Mit integrierten Validatoren für gängige Szenarien, der Möglichkeit, benutzerdefinierte Validierungen zu erstellen, und einer einfachen Möglichkeit, Validierungsregeln zu verketten, ist Fluent Validation ein leistungsstarkes Tool im .NET Core-Toolkit.

Verständnis von Fluent Validation

Fluent Validation ist eine Open-Source-Bibliothek für .NET, mit der Sie auf einfache Weise Validierungsregeln für Ihre Modellklassen erstellen können.

1. Validatoren: Validatoren sind Klassen, die die Validierungslogik kapseln. Sie werden in der Regel durch Vererbung von `AbstractValidatorbasisklasse.

2. Regeln: Eine Regel ist eine Validierungsbedingung, die eine Eigenschaft erfüllen muss. Regeln werden mit der Methode "RuleFor" in einer Validator-Klasse definiert.

3. Validierungsfehler: Wenn eine Regel fehlschlägt, erstellt Fluent Validation ein ValidationFailure-Objekt, das Details über den Fehler enthält, einschließlich des Eigenschaftsnamens und der Fehlermeldung.

Was ist IronPDF?

IronPDF ist eine leistungsfähige .NET-Bibliothek, mit der Sie pDF-Dokumente aus HTML generieren inhalt. Egal, ob Sie Rechnungen, Berichte oder andere Dokumente erstellen müssen, IronPDF bietet eine benutzerfreundliche Lösung. Es lässt sich nahtlos in Ihre ASP.NET Core-Anwendungen integrieren, so dass Sie mit nur wenigen Codezeilen hochwertige PDF-Dateien erzeugen können.

Verwendung von Fluent Validation mit IronPDF

Da wir nun wissen, was Fluent Validation und IronPDF sind, wollen wir sehen, wie sie zusammen verwendet werden können. Dieses Tutorial hilft bei der Erstellung eines Rechnungsgenerators, bei dem der Rechnungsinhalt mit FluentValidation in ASP.NET Core validiert wird, bevor das PDF mit IronPDF erzeugt wird.

Jetzt können wir loslegen!

Einrichten des Projekts

Erstellen Sie zunächst 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 "Konsolenanwendung (ASP.NET Core)" als Projektvorlage 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 einen Namen vergeben und den Speicherort des Repositorys auswählen.

   

    **Konfigurieren Sie die neue Anwendung**

4. Klicken Sie auf die Schaltfläche Next und wählen Sie das .NET-Framework 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, müssen wir die erforderlichen NuGet-Pakete für Fluent Validation und IronPDF hinzufügen.

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 im NuGet Package Manager UI**

3. Suchen Sie in ähnlicher Weise nach "IronPDF" und installieren Sie das IronPDF-Paket.

   Sie können IronPDF jedoch auch über die NuGet Package Manager Console mit dem folgenden Befehl installieren:

Install-Package IronPdf

Installieren Sie das IronPDF-Paket in der Paketmanager-Konsole

Nachdem das Projekt eingerichtet und die erforderlichen Pakete installiert sind, können wir nun die PDF-Inhaltsklasse definieren.

Definieren des PDF-Inhalts

In diesem Beispiel wird eine einfache Rechnungs-PDF-Datei aus den HTML-Codes in den beiden neuen Klassen InvoiceContent und InvoiceItem erstellt.

public abstract class PdfContent
{
    public abstract string RenderHtml();
}

public class InvoiceContent : PdfContent
{
    public string CustomerName { get; set; }
    public string Address { get; set; }
    public List<InvoiceItem> InvoiceItems { get; set; }

    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; }
}

public abstract class PdfContent
{
    public abstract string RenderHtml();
}

public class InvoiceContent : PdfContent
{
    public string CustomerName { get; set; }
    public string Address { get; set; }
    public List<InvoiceItem> InvoiceItems { get; set; }

    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; }
}

Public MustInherit Class PdfContent
	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)

	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 wird eine abstrakte Klasse "PdfContent" mit einer abstrakten Methode namens "RenderHtml" definiert. Die Klasse InvoiceContent erweitert PdfContent und stellt den Inhalt der Rechnungs-PDF dar. Sie hat Eigenschaften für den Kundennamen, die Adresse und eine Liste von Rechnungsposten. Die Klasse "InvoiceItem" enthält zwei Eigenschaften "Beschreibung" und "Preis". Die Methode "RenderHtml" erzeugt das HTML-Markup für die Rechnung auf der Grundlage des Inhalts.

Nachdem nun der PDF-Inhalt definiert ist, können wir mit Fluent Validation Validierungsregeln erstellen.

Validierungsregeln erstellen

Um Validierungsregeln für die Klasse InvoiceContent zu erstellen, erstellen Sie eine Validierungsklasse namens InvoiceContentValidator. Diese Klasse erbt von AbstractValidator<InvoiceContent>, die von Fluent Validation 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 obigen Quellcode ist die Klasse InvoiceContentValidator definiert, die von AbstractValidator erbt`. Innerhalb des Konstruktors der Validator-Klasse definiert die Methode "RuleFor" Validierungsregeln für jede Eigenschaft der Klasse "InvoiceContent".

Zum Beispiel: "RuleFor(inhalt => Inhalt.Kundenname)sie können eine neue Regel definieren, dass der Kundenname nicht leer sein darf. Fluent Validation kann auch die Methode NotEmpty verketten, um diese Validierungsregel zu spezifizieren. In ähnlicher Weise definieren wir Validierungsregeln für die Eigenschaften der Adresse und der Rechnungsposten.

Um die Rechnungsposten zu überprüfen, wird die Methode "RuleForEach" verwendet, um jeden Posten in der Liste "InvoiceItems" zu durchlaufen und einen Validator namens "InvoiceItemValidator" anzuwenden. Die Klasse "InvoiceItemValidator" ist separat definiert und enthält Validierungsregeln für die Klasse "InvoiceItem".

Mit diesen Validierungsregeln können wir nun die PDF-Datei mit IronPDF erstellen.

PDF-Erzeugung mit IronPDF

IronPDF ist eine beliebte .NET-Bibliothek zur Erstellung und Bearbeitung von PDF-Dokumenten. IronPDF wird verwendet, um die PDF-Datei auf der Grundlage des geprüften Rechnungsinhalts zu erstellen.

using IronPdf;
using FluentValidation;

public class PdfService
{
    public PdfDocument GeneratePdf<T>(T content) where T : PdfContent
    {
        var validator = GetValidatorForContent(content);
        FluentValidation.Results.ValidationResult validationResult = validator.Validate(content);

        if (!validationResult.IsValid)
        {
            throw new FluentValidation.ValidationException(validationResult.Errors);
        }

        var renderer = new ChromePdfRenderer();
        return renderer.RenderHtmlAsPdf(content.RenderHtml());
    }

    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
{
    public PdfDocument GeneratePdf<T>(T content) where T : PdfContent
    {
        var validator = GetValidatorForContent(content);
        FluentValidation.Results.ValidationResult validationResult = validator.Validate(content);

        if (!validationResult.IsValid)
        {
            throw new FluentValidation.ValidationException(validationResult.Errors);
        }

        var renderer = new ChromePdfRenderer();
        return renderer.RenderHtmlAsPdf(content.RenderHtml());
    }

    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
	Public Function GeneratePdf(Of T As PdfContent)(ByVal content As T) As PdfDocument
		Dim validator = GetValidatorForContent(content)
		Dim validationResult As FluentValidation.Results.ValidationResult = validator.Validate(content)

		If Not validationResult.IsValid Then
			Throw New FluentValidation.ValidationException(validationResult.Errors)
		End If

		Dim renderer = New ChromePdfRenderer()
		Return renderer.RenderHtmlAsPdf(content.RenderHtml())
	End Function

	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

Im obigen Quellcode definieren wir eine Klasse "PdfService", die eine Methode "GeneratePdf" bereitstellt. Diese Methode nimmt ein "PdfContent"-Objekt als Eingabe und erzeugt das PDF-Dokument auf der Grundlage des geprüften Inhalts.

Zunächst rufen wir den entsprechenden Validator für den Inhalt ab, indem wir die Methode "GetValidatorForContent" aufrufen. Diese Methode prüft den Typ des Inhalts und gibt den entsprechenden Validator zurück. In unserem Fall unterstützen wir nur "InvoiceContent" und verwenden den "InvoiceContentValidator".

Als Nächstes validieren wir den Inhalt mit Hilfe des Validators, indem wir seine validate-Methode aufrufen. Das Ergebnis der Validierung wird in einem ValidationResult-Objekt gespeichert.

Wenn die Validierung fehlschlägt (!validationResult.IsValid)werfen wir eine FluentValidation.ValidationException mit den Validierungsfehlern. Andernfalls wird die PDF-Datei mit IronPDF erstellt.

Wir erstellen eine Instanz von chromePdfRenderer um den HTML-Inhalt als PDF zu rendern. Wir nennen die renderHtmlAsPdf methode auf das htmlToPdf-Objekt und übergeben Sie das von der content.RenderHtml-Methode erzeugte HTML. Dadurch wird das PDF-Dokument erzeugt.

Nachdem wir nun die Logik für die PDF-Erzeugung definiert haben, können wir uns nun um eventuell auftretende Validierungsfehler kümmern.

Behandlung von Validierungsfehlern

Wenn ein Validierungsfehler auftritt, möchten wir eine Fehlermeldung anzeigen und den Fehler angemessen behandeln. Ändern wir die Methode Main der Klasse Program, um Ausnahmen zu behandeln und dem Benutzer aussagekräftige Meldungen anzuzeigen.

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

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

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
		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 hilft ein try-catch-Block dabei, eventuell auftretende Ausnahmen abzufangen. Wenn eine Ausnahme abgefangen wird, wird dem Benutzer mit Console.WriteLine eine Fehlermeldung angezeigt.

Lassen Sie uns nun diese Anwendung mit verschiedenen Szenarien testen, um die PDF-Erzeugung und die Validierungsregeln zu überprüfen.

Testen der Anwendung

In dem Code-Beispiel sind drei Szenarien zu testen:

1. Leerer Kundenname: Lassen Sie den Kundennamen leer, um einen Validierungsfehler auszulösen.

2. Leere Rechnungspositionen: Eine leere Liste von Rechnungspositionen wird bereitgestellt, um einen Validierungsfehler auszulösen.

3. Erfolgreiche Generierung: Geben Sie gültige Inhalte an, um die PDF-Datei 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 PDF-Ausgabedatei

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

Schlussfolgerung

In diesem Tutorium wurde Fluent Validation untersucht und gelernt, wie man es mit IronPDF verwendet, um PDF-Dokumente zu erzeugen. Wir beginnen mit dem Einrichten einer Konsolenanwendung und der Definition der PDF-Inhaltsklasse. Dann erstellte ich mit Fluent Validation Validierungsregeln und testete die PDF-Generierung mit verschiedenen Szenarien.

Fluent Validation bietet einen flexiblen und benutzerfreundlichen Ansatz für die Validierung von Objekten in .NET-Anwendungen. Es ermöglicht Ihnen, Validierungsregeln in einer stark typisierten Weise zu definieren, Fehlermeldungen anzupassen und Validierungsfehler elegant zu behandeln.

IronPDF bietet eine kostenloser Test und die Lizenz beginnt mit $749.