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. Entwickler können mithilfe der fortschrittlichen PDF-Produktionsfunktionen von IronPDF und den starken Validierungsmöglichkeiten von Flunt effektive und zuverlässige Lösungen für eine Vielzahl von Softwareanwendungen konstruieren.

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#

Fließend-Interface: Flunt bietet eine lesbare und prägnante Schnittstelle zum Erstellen von Validierungsregeln, die die Ausdrucksweise komplexer Validierungslogik vereinfacht.

Kettenvalidierung: Kettenvalidierungs-Szenarien können mit wenig Code erstellt werden, indem Validierungsregeln auf natürliche Weise verbunden werden.

Integrierte Validatoren: Flunt bietet mehrere integrierte Validatoren für häufig verwendete Datentypen, darunter Daten, Ganzzahlen, Zeichenfolgen 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 die spezifischen Domänenanforderungen angepasste Validierungslogik ermöglichen.

Benachrichtigungssystem: Um Validierungsprobleme zu melden und Fehlermeldungen zu sammeln, bietet Flunt ein Benachrichtigungssystem an. 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 wie dem Entity Framework und ASP.NET Core verbinden, was es einfach macht, Validierungslogik in bereits bestehende Projekte einzufügen.

Testbarkeit: Flunt erleichtert testgetriebene Entwicklung (TDD), indem es eine klare Trennung zwischen Anwendungscode und Validierungslogik bietet, was das Unit-Testen von Validierungsregeln einfach macht.

Open Source und lebendige Community: 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 Windows Console und Forms

Fluent wird in zahlreichen C#-Anwendungstypen implementiert, darunter Windows-Konsolen-, 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: Dasselbe wie im Beispiel von FluentValidation.

PersonContract: Diese Klasse leitet sich vom grundlegenden Konzept von Flunt's Contract.Verifications ab. Mit der Requires-Methode nimmt der Konstruktor ein Person-Objekt an und stellt Validierungsregeln bereit. Requires bietet eine kaskadierbare Methode, um mehrere Validierungen hinzuzufügen. 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 von FluentValidation.Together mit dem Objekt, erstellt es eine PersonContract-Instanz und ein Person-Objekt. 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.:

Erstellung von Validierungsregeln: Um Validierungsregeln für Attribute wie Pflichtfelder, Datentypen, Wertebereiche, maximale Länge und minimale Länge zu erstellen, verwenden Sie die Fluent-Interface.

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.

Verwaltung von Validierungsfehlern: Notieren und protokollieren Sie Validierungsfehler als Warnungen und reagieren Sie höflich darauf, indem Sie Benutzern Fehlermeldungen geben oder Fehler zur Fehlerbehebung 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 Validierungsmöglichkeiten in aktuellen Anwendungen zu verbessern, kann Flunt nahtlos mit vielen bekannten .NET-Frameworks und -Bibliotheken integriert werden, einschließlich Entity Framework, ASP.NET Core und mehr.

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. Anwendungen können von Entwicklern zuverlässiger und benutzerfreundlicher gestaltet werden, indem IronPDF zur Erstellung von PDF-Dokumenten nach der Validierung der Eingabedaten mit Flunt verwendet wird.

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

Um mehr über die Funktionen, Kompatibilität und weitere Download-Optionen von IronPDF zu erfahren, besuchen Sie die NuGet-Paketdetailseite auf der NuGet-Website.

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 IronPDF ZIP-Downloadseite. 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: Eine Personenklasse mit Attributen für Name und Alter ist definiert. Wir validieren die Personendaten anhand vordefinierter Validierungsregeln, indem wir die fließende Schnittstelle von Flunt im Konstruktor verwenden.

2. PDF generieren: Eine Methode namens RenderHtmlAsPdf wird definiert, die ein Benutzerobjekt als Eingabe akzeptiert. Diese Funktion rendert den HTML-Text, der die Zusammenfassung der Benutzerregistrierung darstellt, in ein PDF-Dokument, indem sie die HtmlToPdf-Klasse von IronPDF verwendet.

3. Main-Methode: Mit Beispiel-Personendaten erstellen wir eine Instanz der User-Klasse in der Main-Methode. Als Nächstes verwenden wir das IsValid-Attribut von Flunt, um zu bestimmen, ob die Personendaten legitim 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. Um mehr über die Funktionen von IronPDF zu erfahren, verweisen Sie auf die Dokumentationsseite. 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 dauerhafte Lizenz und ein Bibliotheks-Upgrade sind alle im $749 Lite-Paket enthalten. IronPDF bietet kostenlose Lizenzierungsdetails von IronPDF an, um weitere Informationen zu Kosten und Lizenzanforderungen zu erhalten. Für weitere Informationen über die Bibliotheken von Iron Software besuchen Sie die offizielle Website von Iron Software.