IRONPDF VERWENDEN

Verwendung der fließenden Validierung mit IronPDF in C#

Name: IronPDF
Brand: Iron Software
Availability: InStock
Rating: 4.87 (307 reviews)

Chipego Kalinda

27. Juni 2023

Aktualisiert 17. März 2024

Teilen Sie:

Was ist Fluent Validation?

FluentValidation ist eine .NET-Validierungsbibliothek, die beim Erstellen 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.

Validatoren: Validatoren sind Klassen, die die Validierungslogik kapseln. Sie werden typischerweise durch Vererbung von der AbstractValidator<T>-Basisklasse erstellt.
Regeln: Eine Regel ist eine Validierungsbedingung, die eine Eigenschaft erfüllen muss. Regeln werden mit der RuleFor-Methode in einer Validator-Klasse definiert.
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 - HTML in PDF umwandeln in C# ist eine leistungsstarke .NET-Bibliothek, die es Ihnen ermöglicht, PDF-Dokumente aus HTML-Inhalten zu erstellen. 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.

Nun lass uns anfangen!

Einrichten des Projekts

Erstellen Sie zunächst eine neue Konsolenanwendung in Visual Studio oder Ihrer bevorzugten Entwicklungsumgebung.

Öffnen Sie Visual Studio und gehen Sie zu Datei > Neu > Projekt.
Wählen Sie "Console App (ASP.NET Core)" als Projekttemplate aus und geben Sie Ihrem Projekt einen Namen.
Erstellen Sie eine neue Konsolenanwendung
Klicken Sie auf die Nächste-Schaltfläche und konfigurieren Sie Ihr Projekt, indem Sie den Namen angeben und den Speicherort des Repositorys auswählen.
Konfigurieren Sie die neue Anwendung
Klicken Sie auf die Weiter-Schaltfläche und wählen Sie das .NET Framework aus. Das neueste .NET Framework (7) wird empfohlen.
.NET Framework-Auswahl
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.

Klicken Sie mit der rechten Maustaste auf das Projekt im Projektmappen-Explorer und wählen Sie "NuGet-Pakete verwalten"
Suchen Sie nach "FluentValidation" und klicken Sie auf "Installieren", um das Paket zu Ihrem Projekt hinzuzufügen.
Installieren Sie das FluentValidation-Paket im NuGet-Paket-Manager-UI
Ähnlich, suchen Sie nach "IronPDF - Leistungsstarke .NET PDF Bibliothek" und installieren Sie das IronPDF-Paket.
Sie können jedoch IronPDF auch mit NuGet-Paket-Manager-Konsole mit dem folgenden Befehl installieren:

Install-Package IronPdf

Wie man Fluent Validation mit IronPDF in C# verwendet, Abbildung 5: Installieren Sie das IronPdf-Paket in der Paket-Manager-Konsole

Installieren Sie das IronPdf-Paket in der Package Manager-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 ein einfaches Rechnungs-PDF aus den HTML-Codes in den neuen zwei 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

$vbLabelText $csharpLabel

Im obigen Code wird eine abstrakte PdfContent-Klasse definiert, die eine abstrakte Methode namens RenderHtml enthält. Die Klasse InvoiceContent erweitert PdfContent und repräsentiert den Inhalt der PDF-Rechnung. Sie hat Eigenschaften für den Kundennamen, die Adresse und eine Liste von Rechnungsposten. Die InvoiceItem-Klasse enthält zwei Eigenschaften 'Description' und 'Price'. Die RenderHtml-Methode erzeugt das HTML-Markup für die Rechnung basierend auf dem Inhalt.

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

Validierungsregeln erstellen

Um Validierungsregeln für die InvoiceContent-Klasse zu erstellen, erstellen Sie eine Validator-Klasse namens InvoiceContentValidator. Diese Klasse wird von AbstractValidator<InvoiceContent> erben, 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

$vbLabelText $csharpLabel

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

Zum Beispiel kann RuleFor(content => content.CustomerName) eine neue Regel definieren, dass der Kundenname nicht leer sein sollte. Fluent Validation kann auch die NotEmpty-Methode verketten, um diese Validierungsregel festzulegen. In ähnlicher Weise definieren wir Validierungsregeln für die Eigenschaften der Adresse und der Rechnungsposten.

Um die Rechnungspositionen zu validieren, wird die RuleForEach-Methode verwendet, um über jede Position in der InvoiceItems-Liste zu iterieren und einen Validator namens InvoiceItemValidator anzuwenden. Die InvoiceItemValidator-Klasse wird separat definiert und enthält Validierungsregeln für die InvoiceItem-Klasse.

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

PDF-Erzeugung mit IronPDF

IronPDF - Erstellen und Bearbeiten von PDF-Dokumenten ist eine beliebte .NET-Bibliothek zum Erstellen und Bearbeiten 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

$vbLabelText $csharpLabel

Im obigen Quellcode definieren wir eine PdfService-Klasse, die eine GeneratePdf-Methode bereitstellt. Diese Methode nimmt ein PdfContent-Objekt als Eingabe und generiert das PDF-Dokument basierend auf dem validierten Inhalt.

Zuerst rufen wir den entsprechenden Validator für den Inhalt ab, indem wir die GetValidatorForContent-Methode 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 Validierungsergebnis 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 rufen die RenderHtmlAsPdf-Methode auf das htmlToPdf-Objekt auf und übergeben das von der content.RenderHtml-Methode generierte 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. Lassen Sie uns die Main-Methode der Program-Klasse ändern, um Ausnahmen zu behandeln und dem Benutzer aussagekräftige Nachrichten 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

$vbLabelText $csharpLabel

Im obigen Code hilft ein try-catch-Block, um alle Ausnahmen abzufangen, die auftreten könnten. Wenn eine Ausnahme abgefangen wird, wird dem Benutzer eine Fehlermeldung mit Console.WriteLine 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:

Leerer Kundenname: Lassen Sie den Kundennamen leer, um einen Validierungsfehler auszulösen.
Leere Rechnungspositionen: Eine leere Liste von Rechnungspositionen wird bereitgestellt, um einen Validierungsfehler auszulösen.
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!

Wie man Fluent Validation mit IronPDF in C# verwendet, Abbildung 6: Der Ausgabefehler in der Konsole

Der Ausgabefehler in der Konsole

Verwendung von Fluent Validation mit IronPDF in C#, Abbildung 7: Die Ausgabedatei im PDF-Format

Die Ausgabedatei im PDF-Format

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 Free Trial & Licensing Information bietet eine kostenlose Testversion an und die Lizenz beginnt bei $499 pro Entwickler.

Chipego Kalinda

Jetzt mit dem Ingenieurteam chatten

Software-Ingenieur

Chipego hat eine natürliche Fähigkeit zum Zuhören, die ihm hilft, Kundenprobleme zu verstehen und intelligente Lösungen anzubieten. Er trat dem Iron Software-Team 2023 bei, nachdem er einen Bachelor of Science in Informationstechnologie erworben hatte. IronPDF und IronOCR sind die beiden Produkte, auf die sich Chipego konzentriert hat, aber sein Wissen über alle Produkte wächst täglich, da er neue Wege findet, Kunden zu unterstützen. Er genießt die Zusammenarbeit bei Iron Software, da Teammitglieder aus dem gesamten Unternehmen ihre unterschiedlichen Erfahrungen einbringen und so zu effektiven, innovativen Lösungen beitragen. Wenn Chipego nicht an seinem Schreibtisch sitzt, kann man ihn oft bei einem guten Buch oder beim Fußballspielen antreffen.

< PREVIOUS
PDF vs. PDFA (Wie es für Entwickler funktioniert)

NÄCHSTES >
Wie ChatGPT mit IronPDF für C#-Entwickler verwendet wird