Flunt C# (Wie es für Entwickler funktioniert)

Einführung

In der heutigen Softwareentwicklungsumgebung sind die Erstellung einer hochwertigen Dokumentation und die Gewährleistung der Datenintegrität wesentliche Aufgaben. In diesem Beitrag sehen wir uns an, wie die leistungsstarken C#-Bibliotheken Flunt C# und IronPDF kombiniert werden können, um die Arbeitsabläufe bei der Datenvalidierung und Dokumentenerstellung zu verbessern. Die Entwickler können effektive und zuverlässige Lösungen für eine Vielzahl von anwendungen durch Nutzung der hochentwickelten PDF-Produktionsfunktionen von IronPDF und der starken Validierungsfunktionen von Flunt.

Die Verwendung von Flunt in C##

1. Erstellen Sie ein neues C#-Konsolenprojekt.

2. Installieren Sie das Flunt-Paket von Nuget.

3. Importieren Sie den Namespace und erben Sie die Klasse.

4. Fügen Sie die Validierung zum Datenmodell hinzu.

5. Validierungsprüfungen durchführen und das Ergebnis anzeigen.

Verständnis von Flunt C#

Das vielseitige und leichtgewichtige .NET-Framework Flunt wurde entwickelt, um die Entwicklung von fließenden Validierungs- und Benachrichtigungsmustern in C#-Anwendungen zu erleichtern. Der Code wird besser lesbar und wartbar, wenn Entwickler Flunt verwenden, um Validierungsregeln und Geschäftslogik flüssig und ausdrucksstark zu konstruieren. Mit dem umfangreichen Angebot an integrierten Validierungstechniken und -erweiterungen von Flunt können Entwickler komplizierte Datenstrukturen wie Objekte und Sammlungen problemlos validieren.

Darüber hinaus ist Flunt ein nützliches Werkzeug, um die Zuverlässigkeit und Robustheit von Anwendungen in der NET-Bibliothek zu erhöhen, da es sich leicht in aktuelle Codebasen und Frameworks integrieren lässt. Alles in allem fördert Flunt einen deklarativen Ansatz bei der Validierung und Fehlerbehandlung, der es Entwicklern ermöglicht, saubereren und robusteren Code zu schreiben.

Merkmale von Flunt C#

Fluent Interface: Flunt bietet eine gut lesbare und prägnante Schnittstelle für die Erstellung von Validierungsregeln, die den Ausdruck komplexer Validierungslogik vereinfacht.

Verkettbare Validierung: Verkettbare Validierungsszenarien können mit wenig Code erstellt werden, indem Validierungsregeln natürlich miteinander verbunden werden.

Integrierte Validatoren: Flunt verfügt über mehrere integrierte Validatoren für häufig verwendete Datentypen, einschließlich Datumsangaben, Ganzzahlen, Strings und Sammlungen. Eine flüssige Syntax ermöglicht die einfache Anwendung dieser Validatoren auf Eigenschaften.

Benutzerdefinierte Validierungsregeln: Durch die Erweiterung des Flunt-Frameworks können Entwickler benutzerdefinierte Validierungsregeln hinzufügen, die eine an bestimmte Domänenanforderungen angepasste Validierungslogik ermöglichen.

Benachrichtigungssystem: Um Validierungsprobleme zu melden und Fehlermeldungen zu sammeln, bietet Flunt ein Benachrichtigungssystem. Dies macht es für Entwickler einfach, Benutzer oder andere Anwendungskomponenten über Validierungsfehler zu informieren.

Integration mit Frameworks: Flunt lässt sich problemlos mit bekannten Frameworks und Bibliotheken, einschließlich Entity Framework und ASP.NET Core, verbinden, was das Hinzufügen von Validierungslogik zu bereits bestehenden Projekten erleichtert.

Testbarkeit: Flunt erleichtert die testgetriebene Entwicklung (TDD) indem es eine klare Trennung zwischen Anwendungscode und Validierungslogik bietet, was die Durchführung von Unit-Tests für Validierungsregeln erleichtert.

Open Source und florierende Gemeinschaft: Eine Gruppe von Entwicklern pflegt Flunt aktiv und macht es zu einer Open-Source-Software. Dies garantiert eine kontinuierliche Wartung, Verbesserung und Unterstützung des Frameworks.

Erste Schritte mit Flunt C#

Einrichten von Flunt in C# Projekten

Der Notifications- und Validation-Namespace ist Teil der Flunt Base Class Library und sollte in Ihrem C#-Projekt standardmäßig zugänglich sein. Flunt beschleunigt die Validierung von C#-Programmen, indem es eine flexible Schnittstelle für die Definition und Anwendung von Validierungsregeln bietet. Die Unterstützung für sauberen Code, verbesserte Lesbarkeit und gründliche Fehlerbehandlung erleichtert die Validierung von Benutzereingaben, Domänenobjekten und API-Anforderungen.

Implementierung von Flunt in der Windows-Konsole und in Formularen

Flunt wird von zahlreichen C#-Anwendungstypen implementiert, darunter Windows Console, Webanwendungen und Windows Forms (WinForms). Obwohl jeder Rahmen eine andere Implementierung hat, ist das allgemeine Konzept immer das gleiche.

Flunt C# Beispiel

Sie können den folgenden Code Flunt verwenden, sobald er installiert ist. Dies ist ein einfaches Beispiel, das Ihnen zeigt, wie Sie mit Flunt Validierungsregeln erstellen können:

using Flunt.Validations;
static void Main(string[] args)
{
    var person = new Person { Name = "Jack", Age = -25 };
    var contract = new PersonContract(person);
    // validation checks
    if (contract.IsValid)
    {
        Console.WriteLine("Person is valid!");
    }
    else
    {
            Console.WriteLine("Validation failed:");
            foreach (var notification in contract.Notifications)
            {
                Console.WriteLine($"- {notification.Key}:{notification.Message}");
            }
    }
}
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
public class PersonContract : Contract<Person>
{
public PersonContract(Person person)
    {
        // ensure the correct format of the object
        Requires()
            .IsNotNull(person, nameof(person))
        .IsNotEmpty(person.Name, nameof(person.Name), "Name is required")
            .IsGreaterThan(person.Age, 0, nameof(person.Age), "Age must be a positive number");
    }
}

using Flunt.Validations;
static void Main(string[] args)
{
    var person = new Person { Name = "Jack", Age = -25 };
    var contract = new PersonContract(person);
    // validation checks
    if (contract.IsValid)
    {
        Console.WriteLine("Person is valid!");
    }
    else
    {
            Console.WriteLine("Validation failed:");
            foreach (var notification in contract.Notifications)
            {
                Console.WriteLine($"- {notification.Key}:{notification.Message}");
            }
    }
}
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
public class PersonContract : Contract<Person>
{
public PersonContract(Person person)
    {
        // ensure the correct format of the object
        Requires()
            .IsNotNull(person, nameof(person))
        .IsNotEmpty(person.Name, nameof(person.Name), "Name is required")
            .IsGreaterThan(person.Age, 0, nameof(person.Age), "Age must be a positive number");
    }
}

Imports Flunt.Validations
Shared Sub Main(ByVal args() As String)
	Dim person As New Person With {
		.Name = "Jack",
		.Age = -25
	}
	Dim contract = New PersonContract(person)
	' validation checks
	If contract.IsValid Then
		Console.WriteLine("Person is valid!")
	Else
			Console.WriteLine("Validation failed:")
			For Each notification In contract.Notifications
				Console.WriteLine($"- {notification.Key}:{notification.Message}")
			Next notification
	End If
End Sub
Public Class Person
Public Property Name() As String
Public Property Age() As Integer
End Class
Public Class PersonContract
	Inherits Contract(Of Person)

Public Sub New(ByVal person As Person)
		' ensure the correct format of the object
		Requires().IsNotNull(person, NameOf(person)).IsNotEmpty(person.Name, NameOf(person.Name), "Name is required").IsGreaterThan(person.Age, 0, NameOf(person.Age), "Age must be a positive number")
End Sub
End Class

Person Klasse: Die gleiche wie im Beispiel von FluentValidation.

PersonContract: Diese Klasse leitet sich von Flunts grundlegendem Konzept der Contract.Verifications ab. Mit der Methode Requires nimmt der Konstruktor ein Person-Objekt und liefert Validierungsregeln. requires" bietet eine verkettbare Methode zum Hinzufügen mehrerer Validierungen. Validierungen werden durch Methoden wie IsNotNull, NotEmpty, HasMinLength und IsGreaterThan durchgeführt. Für jede Validierungsregel sind personalisierte Fehlermeldungen verfügbar.

Validierung: Vergleichbar mit dem Beispiel der FluentValidation, die zusammen mit dem Objekt eine PersonContract-Instanz und ein Person-Objekt erzeugt. Das Ergebnis der Validierung wird durch das Attribut Valid des Vertrags angezeigt. Je nach Ergebnis der Validierung werden Meldungen über Erfolg oder Misserfolg sowie bestimmte Fehlerdetails angezeigt.

Flunt-Operationen

Für die Validierung und den Umgang mit Benachrichtigungen in C#-Anwendungen bietet Flunt zahlreiche Operationen, wie z. B.:

Erstellen von Überprüfungsregeln: Um Überprüfungsregeln für Attribute wie Pflichtfelder, Datentypen, Wertebereiche, Maximallänge und Minimallänge zu erstellen, verwenden Sie die Fließschnittstelle.

Ausführen der Validierung: Um die Datenintegrität und die Einhaltung der Geschäftslogik zu gewährleisten, müssen Objekte anhand vordefinierter Regeln validiert werden.

Management von Validierungsfehlern: Notieren Sie Validierungsfehler als Warnungen und reagieren Sie höflich darauf, indem Sie den Benutzern Fehlermeldungen geben oder Fehler für die Fehlersuche aufzeichnen. Personalisierte Validierungslogik Verwenden Sie einzigartige Validierungsregeln, um Flunt als Reaktion auf komplizierte Validierungsumstände oder besondere Domänenanforderungen zu erweitern.

Integration mit Frameworks: Um die Validierungsfunktionen in aktuellen Anwendungen zu verbessern, kann Flunt nahtlos in viele bekannte .NET-Frameworks und -Bibliotheken integriert werden, darunter Entity Framework, ASP.NET Core und andere.

Integration von Flunt in IronPDF

Durch die Integration von Flunt mit IronPDF können Entwickler die Stärken beider Technologien nutzen, um die Validierung der Geschäftslogik und die Erstellung von Dokumenten in C#-Anwendungen zu beschleunigen. Mit IronPDF können Entwickler ihre Anwendungen zuverlässiger, verlässlicher und benutzerfreundlicher gestalten, indem sie PDF-Dokumente nach der Validierung der Eingabedaten mit Flunt erstellen.

IronPDF installieren

• Starten Sie das Visual Studio-Projekt.
• Wählen Sie "Werkzeuge" > "NuGet Package Manager" > "Package Manager Console".
• Geben Sie diesen Befehl in die Paketmanager-Konsole ein:

Install-Package IronPdf

• Alternativ können Sie den NuGet Package Manager for Solutions verwenden, um IronPDF und andere erforderliche NuGet-Pakete zu installieren.

• Klicken Sie auf die Schaltfläche "Installieren", nachdem Sie das IronPDF-Paket aus den Suchergebnissen ausgewählt haben. Die Installation und der Download werden von Visual Studio übernommen.

  

• Die Installation des IronPDF-Pakets und aller Abhängigkeiten, die Sie für Ihr Projekt benötigen, wird von NuGet übernommen.
• Nach der Installation steht IronPDF für die Verwendung in Ihrem Projekt zur Verfügung.

Installation über die NuGet-Website

Weitere Informationen über die Funktionen von IronPDF, seine Kompatibilität und andere Download-Möglichkeiten finden Sie auf der NuGet-Website unter https://www.nuget.org/packages/IronPdf.

DLL zur Installation verwenden

Als Alternative können Sie die DLL-Datei von IronPDF verwenden, um sie direkt in Ihr Projekt einzubinden. Um die ZIP-Datei mit der DLL zu erhalten, besuchen Sie die folgende Seite link. Sobald die DLL entpackt ist, fügen Sie sie in Ihr Projekt ein.

Umsetzung der Logik

Lassen Sie uns eine einfache C#-Anwendung erstellen, die IronPDF für die PDF-Erstellung und Flunt für die Datenvalidierung verwendet. In diesem Beispiel werden wir Flunt verwenden, um die Benutzereingaben für ein Registrierungsformular zu validieren, und IronPDF, um ein PDF-Dokument mit einer Zusammenfassung der überprüften Benutzerdaten zu erstellen.

1. Personenklasse: Es wird eine Personenklasse mit Attributen für Name und Alter definiert. Wir validieren die Personendaten anhand vordefinierter Validierungsregeln, indem wir die fließende Schnittstelle von Flunt im Konstruktor verwenden.

2. Pdf erzeugen: Es wird eine Methode namens "RenderHtmlAsPdf" definiert, die ein Benutzerobjekt als Eingabe akzeptiert. Mit dieser Funktion wird der HTML-Text, der die Zusammenfassung der Benutzerregistrierung darstellt, mit Hilfe der IronPDF-Klasse HtmlToPdf in ein PDF-Dokument umgewandelt.

3. Hauptmethode: Mit Hilfe der Beispieldaten von Person erstellen wir in der Methode Main eine Instanz der Klasse User. Als nächstes verwenden wir das Attribut "IsValid" von Flunt, um festzustellen, ob die Personendaten rechtmäßig sind. Um das PDF-Dokument zu erstellen, rufen wir die IronPDF-Methode auf, wenn die Daten korrekt sind. Ist dies nicht der Fall, werden die Validierungsprobleme in der Konsole angezeigt.

   Wir haben einen schnellen Workflow für die Auswertung von Benutzereingaben und die Erstellung von PDF-Dokumenten in einer C#-Anwendung entwickelt, indem wir IronPDF für die PDF-Erzeugung mit Flunt für die Datenvalidierung kombiniert haben. Diese Methode gewährleistet die Integrität der Daten, erzeugt Arbeiten von hoher Qualität und fördert das Schreiben von klarem, lesbarem und wartbarem Code. Mehr über IronPDF erfahren Sie unter hier. Nachstehend finden Sie ein Beispiel für einen Codeausschnitt.

using IronPdf;
using System;
using System.Linq;
using System.Text;
using Flunt.Validations;
namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            StringBuilder sb = new StringBuilder();
            var person = new Person { Name = "Jack", Age = -25 };
            var contract = new PersonContract(person);
            if (contract.IsValid)
            {
                Console.WriteLine("Person is valid!");
            }
            else
            {
                sb.Append("<p>Validation failed: </p>");
                foreach (var notification in contract.Notifications)
                {
                    sb.Append($"- {notification.Key}: {notification.Message}");
                }
            }
            var renderer = new IronPdf.HtmlToPdf();
            //Set HTML content for the page
            var pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString());
            // save the document
            pdfDocument.SaveAs("output.pdf");
            //Dispose the render object
            renderer.Dispose();
            //Display a message
            Console.WriteLine("Report generated successfully!");
        }
    }
    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
    public class PersonContract : Contract<Person>
    {
        public PersonContract(Person person)
        {
            Requires()
                .IsNotNull(person, nameof(person))
            .IsNotEmpty(person.Name, nameof(person.Name), "Name is required")
                .IsGreaterThan(person.Age, 0, nameof(person.Age), "Age must be a positive number");
        }
    }
}

using IronPdf;
using System;
using System.Linq;
using System.Text;
using Flunt.Validations;
namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            StringBuilder sb = new StringBuilder();
            var person = new Person { Name = "Jack", Age = -25 };
            var contract = new PersonContract(person);
            if (contract.IsValid)
            {
                Console.WriteLine("Person is valid!");
            }
            else
            {
                sb.Append("<p>Validation failed: </p>");
                foreach (var notification in contract.Notifications)
                {
                    sb.Append($"- {notification.Key}: {notification.Message}");
                }
            }
            var renderer = new IronPdf.HtmlToPdf();
            //Set HTML content for the page
            var pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString());
            // save the document
            pdfDocument.SaveAs("output.pdf");
            //Dispose the render object
            renderer.Dispose();
            //Display a message
            Console.WriteLine("Report generated successfully!");
        }
    }
    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
    public class PersonContract : Contract<Person>
    {
        public PersonContract(Person person)
        {
            Requires()
                .IsNotNull(person, nameof(person))
            .IsNotEmpty(person.Name, nameof(person.Name), "Name is required")
                .IsGreaterThan(person.Age, 0, nameof(person.Age), "Age must be a positive number");
        }
    }
}

Imports IronPdf
Imports System
Imports System.Linq
Imports System.Text
Imports Flunt.Validations
Namespace ConsoleApp
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			Dim sb As New StringBuilder()
			Dim person As New Person With {
				.Name = "Jack",
				.Age = -25
			}
			Dim contract = New PersonContract(person)
			If contract.IsValid Then
				Console.WriteLine("Person is valid!")
			Else
				sb.Append("<p>Validation failed: </p>")
				For Each notification In contract.Notifications
					sb.Append($"- {notification.Key}: {notification.Message}")
				Next notification
			End If
			Dim renderer = New IronPdf.HtmlToPdf()
			'Set HTML content for the page
			Dim pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString())
			' save the document
			pdfDocument.SaveAs("output.pdf")
			'Dispose the render object
			renderer.Dispose()
			'Display a message
			Console.WriteLine("Report generated successfully!")
		End Sub
	End Class
	Public Class Person
		Public Property Name() As String
		Public Property Age() As Integer
	End Class
	Public Class PersonContract
		Inherits Contract(Of Person)

		Public Sub New(ByVal person As Person)
			Requires().IsNotNull(person, NameOf(person)).IsNotEmpty(person.Name, NameOf(person.Name), "Name is required").IsGreaterThan(person.Age, 0, NameOf(person.Age), "Age must be a positive number")
		End Sub
	End Class
End Namespace

Nachfolgend sehen Sie die Ausgabe der Ausführung des obigen Codes:

Schlussfolgerung

IronPDF und Flunt sind zwei leistungsstarke C#-Bibliotheken, die gut zusammenarbeiten, um Arbeitsabläufe für die Dokumentenerstellung und Datenvalidierung zu rationalisieren. Mit den ausgefeilten PDF-Produktionsfunktionen von IronPDF und den leistungsstarken Validierungsfunktionen von Flunt können Entwickler zuverlässige, effektive und hochkarätige Lösungen für eine Vielzahl von Anwendungen erstellen. Flunt und IronPDF geben Entwicklern die nötigen Werkzeuge an die Hand, um qualitativ hochwertige Software zu erstellen, die den Anforderungen von Anwendern und Stakeholdern gerecht wird - unabhängig davon, ob sie Desktop-Anwendungen, Web-Applikationen oder Cloud-basierte Lösungen entwickeln.

Ein Jahr Software-Support, eine permanente Lizenz und ein Bibliotheks-Upgrade sind im "Lite-Lizenz"-Paket enthalten. IronPDF bietet freie Lizenzvergabe von IronPDF für weitere Einzelheiten zu Kosten und Lizenzanforderungen. Weitere Informationen zu den Iron Software Bibliotheken finden Sie hier website.