Flunt C# (Funktionsweise für Entwickler)

Wie verwendet man Flunt in C#?

1. Erstellen Sie ein neues C#-Konsolenprojekt.
2. Installieren Sie das Flunt-Paket über NuGet.
3. Importieren Sie den Namespace und erben Sie die Klasse.
4. Fügen Sie die Validierung zum Datenmodell hinzu.
5. Führen Sie Validierungsprüfungen durch und zeigen Sie das Ergebnis an.

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. Code wird lesbarer und wartbarer, wenn Entwickler Flunt verwenden, um Validierungsregeln und Geschäftslogik auf flüssige und ausdrucksstarke Weise zu konstruieren. Dank Flunts umfangreicher Palette integrierter Validierungstechniken und Erweiterungen können Entwickler problemlos komplexe Datenstrukturen wie Objekte und Sammlungen validieren.

Darüber hinaus ist Flunt ein nützliches Werkzeug zur Erhöhung der Zuverlässigkeit und Robustheit von .NET-Bibliotheksanwendungen, da es sich problemlos in bestehende Codebasen und Frameworks integrieren lässt. Alles in allem fördert Flunt einen deklarativen Ansatz zur Validierung und Fehlerbehandlung, der es Entwicklern ermöglicht, saubereren und robusteren Code zu schreiben.

Einstieg in Flunt C

Flunt C# Beispiel

Sobald Flunt installiert ist, können Sie den folgenden Code verwenden. Dies ist ein einfaches Beispiel, das zeigt, wie man Flunt zur Erstellung von Validierungsregeln verwendet:

using System;
using Flunt.Validations;

public class Program
{
    static void Main(string[] args)
    {
        var person = new Person { Name = "Jack", Age = -25 };
        var contract = new PersonContract(person);

        // Perform 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 System;
using Flunt.Validations;

public class Program
{
    static void Main(string[] args)
    {
        var person = new Person { Name = "Jack", Age = -25 };
        var contract = new PersonContract(person);

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

Person-Klasse: Stellt eine Entität mit Name- und Age-Eigenschaften dar.

PersonContract: Diese Klasse leitet sich von Flunts Grundkonzept eines Contract ab. Der Konstruktor verwendet die Requires-Methode, um ein Person-Objekt entgegenzunehmen und Validierungsregeln bereitzustellen. Requires bietet eine verkettbare Methode für die Definition mehrerer Validierungen. Validierungen werden durch Methoden wie IsNotNull, IsNotEmpty, IsGreaterThan durchgeführt. Jede Validierungsregel hat eine zugehörige benutzerdefinierte Fehlermeldung.

Validierung: Ähnlich zu einem FluentValidation-Beispiel erstellt dies eine Instanz einer PersonContract und eines Person-Objekts. Die Validierungsergebnisse werden durch das Attribut IsValid des Vertrags angezeigt. Erfolgsmeldungen oder Misserfolgsmeldungen sowie spezifische Fehlermeldungen werden basierend auf dem Validierungsergebnis angezeigt.

Flunt-Operationen

Zur Validierung und Benachrichtigungsbehandlung in C#-Anwendungen bietet Flunt viele Operationen, wie zum Beispiel:

Erstellen von Validierungsregeln: Verwenden Sie die flüssige Schnittstelle, um Validierungsregeln für Attribute wie Pflichtfelder, Datentypen, Wertebereiche, maximale Länge und minimale Länge zu erstellen.

Durchführen von Validierungen: Validiere Objekte gegen vordefinierte Regeln, um die Datenintegrität und die Einhaltung der Geschäftslogik zu gewährleisten.

Umgang mit Validierungsfehlern: Notieren und protokollieren Sie Validierungsfehler als Warnungen und reagieren Sie höflich darauf, indem Sie den Benutzern Fehlermeldungen anzeigen oder Fehler zum Troubleshooting aufzeichnen.

Benutzerdefinierte Validierungslogik: Verwenden Sie einzigartige Validierungsregeln, um Flunt in Reaktion auf komplexe Validierungsszenarien oder spezifische Domänenanforderungen zu erweitern.

Integration mit Frameworks: Um die Validierungsfunktionen in bestehenden Anwendungen zu verbessern, lässt sich Flunt nahtlos mit vielen bekannten .NET-Frameworks und Bibliotheken, einschließlich Entity Framework, ASP.NET Core und mehr, integrieren.

Einbindung von Flunt in IronPDF

Entwickler können die Stärken beider Technologien nutzen, um die Validierung der Geschäftslogik und die Dokumentenerstellung in C#-Anwendungen zu beschleunigen, indem sie Flunt mit IronPDF integrieren. Anwendungen können durch Entwickler zuverlässiger und benutzerfreundlicher gemacht werden, indem sie IronPDF zum Erstellen von PDF-Dokumenten verwenden, nachdem sie Eingabedaten mit Flunt validiert haben.

IronPDF installieren

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

Install-Package IronPdf

• Alternativ können Sie den NuGet-Paket-Manager für Lösungen verwenden, um IronPDF und andere erforderliche NuGet-Pakete zu installieren.
• Klicken Sie auf die Schaltfläche "Installieren", nachdem Sie das IronPDF-Paket in den Suchergebnissen durchsucht und ausgewählt haben. Die Installation und der Download werden von Visual Studio gehandhabt.

• Die Installation des IronPDF-Pakets und aller Abhängigkeiten, die für Ihr Projekt erforderlich sind, wird von NuGet übernommen.
• Nach der Installation steht IronPDF für Ihr Projekt zur Verfügung.

Implementierung von Logik

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

1. Person-Klasse: Eine Person-Klasse mit Attributen für Namen und Alter ist definiert. Wir validieren die Person-Daten anhand vordefinierter Validierungsregeln, indem wir in dem Konstruktor Flunts flüssige Schnittstelle verwenden.
2. PDF erzeugen: Es wird eine Methode namens RenderHtmlAsPdf definiert, die ein Benutzerobjekt als Eingabe akzeptiert. Diese Funktion rendert den HTML-Text, der die Benutzerregistrierungszusammenfassung darstellt, indem sie die HtmlToPdf-Klasse von IronPDF verwendet, in ein PDF-Dokument.
3. Hauptmethode: Mithilfe von Beispiel-Personendaten erstellen wir eine Instanz der Benutzerklasse in der Hauptmethode. Als nächstes nutzen wir das IsValid-Attribut von Flunt, um zu bestimmen, ob die Person-Daten gültig sind. Um das PDF-Dokument zu erstellen, rufen wir die IronPdf-Methode auf, wenn die Daten korrekt sind. Wenn nicht, werden die Validierungsprobleme auf der Konsole angezeigt.

Wir haben einen schnellen Arbeitsablauf für die Bewertung von Benutzereingaben und die Erstellung von PDF-Dokumenten in einer C#-Anwendung entwickelt, indem wir IronPDF zur PDF-Erstellung mit Flunt zur Datenvalidierung kombiniert haben. Dieses Verfahren gewährleistet die Datenintegrität, erzeugt professionelle Dokumente und fördert das Schreiben von klarem, lesbarem und wartbarem Code. Um mehr über die Fähigkeiten von IronPDF zu erfahren, lesen Sie die Dokumentationsseite. Nachfolgend finden Sie den Beispielcodeausschnitt.

using IronPdf;
using System;
using System.Linq;
using System.Text;
using Flunt.Validations;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // StringBuilder for HTML content
            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!");
                sb.Append("<p>Person is valid!</p>");
            }
            else
            {
                sb.Append("<p>Validation failed: </p>");
                foreach (var notification in contract.Notifications)
                {
                    sb.Append($"- {notification.Key}: {notification.Message}<br>");
                }
            }

            var renderer = new HtmlToPdf();
            // Set HTML content for the page
            var pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString());
            // Save the document
            pdfDocument.SaveAs("output.pdf");
            // Dispose the renderer 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 for HTML content
            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!");
                sb.Append("<p>Person is valid!</p>");
            }
            else
            {
                sb.Append("<p>Validation failed: </p>");
                foreach (var notification in contract.Notifications)
                {
                    sb.Append($"- {notification.Key}: {notification.Message}<br>");
                }
            }

            var renderer = new HtmlToPdf();
            // Set HTML content for the page
            var pdfDocument = renderer.RenderHtmlAsPdf(sb.ToString());
            // Save the document
            pdfDocument.SaveAs("output.pdf");
            // Dispose the renderer 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");
        }
    }
}

Nachfolgend finden Sie die Ausführungsausgabe des obigen Codes:

Abschluss

IronPDF und Flunt sind zwei starke 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 starken Validierungsmöglichkeiten von Flunt können Entwickler zuverlässige, effektive und qualitativ hochwertige Lösungen für eine Vielzahl von Anwendungen konstruieren. Flunt und IronPDF statten Entwickler mit den Werkzeugen aus, die notwendig sind, um hochwertige Software zu erstellen, die den Bedürfnissen von Benutzern und Interessensgruppen gerecht wird, sei es bei der Entwicklung von Desktop-Anwendungen, Webanwendungen oder Cloud-basierten Lösungen.

Ein Jahr Software-Support, eine dauerhafte Lizenz und ein Bibliotheks-Upgrade sind alle im $799 Lite-Bundle enthalten. IronPDF bietet kostenlose Lizenzierungsdetails von IronPDF für weitere Details zu Kosten und Lizenzanforderungen. Weitere Informationen über die Iron Software-Bibliotheken finden Sie auf der offiziellen Iron Software-Website.