W obecnym srodowisku rozwoju oprogramowania wytwarzanie dokumentacji wysokiej jakosci i gwarantowanie integralnosci danych sa niezbędnymi zadaniami. W tym poscie przyjrzymy sie, jak polaczyc potężne biblioteki C#, Flunt C# i IronPDF, aby poprawić przeplywy pracy związane z walidacja danych i tworzeniem dokumentów. Programisci mogą konstruować efektywne i niezawodne rozwiązania dla różnych aplikacji wykorzystując zaawansowane funkcje produkcji PDF w IronPDF i silne zdolności walidacyjne w Flunt.

How to use Flunt in C#

1. Utwórz nowy projekt konsoli C#.
2. Zainstaluj pakiet Flunt z NuGet.
3. Zaimportuj przestrzeń nazw i odziedzicz klasę.
4. Dodaj walidację do modelu danych.
5. Przeprowadź kontrole walidacji i wyświetl wynik.

Understanding of Flunt C#

Wszechstronny i lekki framework .NET, Flunt, został stworzony w celu ułatwienia rozwoju płynnych wzorców walidacji i powiadamiania w aplikacjach C#. Kod staje się bardziej czytelny i łatwiejszy w utrzymaniu, gdy programiści używają Flunt do konstruowania reguł walidacji i logiki biznesowej w płynny i wyrazisty sposób. Dzięki szerokiemu zakresowi zintegrowanych technik walidacji i rozszerzeń Flunt, programiści mogą łatwo walidować złożone struktury danych, takie jak obiekty i kolekcje.

Co więcej, Flunt jest użytecznym narzędziem do zwiększania niezawodności i wytrzymałości aplikacji bibliotek .NET, ponieważ łatwo integruje się z obecnymi bazami kodu i frameworkami. Podsumowując, Flunt promuje deklaratywne podejście do walidacji i obsługi błędów, umożliwiając programistom pisanie czystszego, bardziej odpornego kodu.

Features of Flunt C#

Płynny interfejs: Flunt oferuje czytelny i zwięzły interfejs do budowy reguł walidacji, co upraszcza wyrażanie złożonej logiki walidacji.

Łańcuchowalna walidacja: Scenariusze walidacji łancuchowej mogą być tworzone przy minimalnym kodzie poprzez naturalne laczenie reguł walidacji.

Zintegrowane walidatory: Flunt zawiera kilka wbudowanych walidatorów dla często używanych typów danych, w tym daty, liczb całkowitych, ciągów znaków i kolekcji. Składnia płynna umożliwia łatwe zastosowanie tych walidatorów do właściwości.

Niestandardowe reguły walidacji: Rozszerzając framework Flunt, programiści mogą dodawać niestandardowe reguły walidacji, które pozwalają na logikę walidacji dostosowaną do określonych wymagań dziedziny.

System powiadomień: Aby raportować problemy z walidacją i zbierać komunikaty o błędach, Flunt oferuje system powiadomień. Dzięki temu programiści mogą łatwo informować użytkowników lub inne komponenty aplikacji o niepowodzeniach walidacji.

Integracja z frameworkami: Flunt łatwo łączy się ze znanymi frameworkami i bibliotekami, takimi jak Entity Framework i ASP.NET Core, co umożliwia proste dodanie logiki walidacji do już istniejących projektów.

Testowalność: Flunt ułatwia rozwój napędzany testami (TDD), oferując wyraźny podział między kodem aplikacji a logiką walidacji, co sprawia, że reguły walidacji można łatwo testować jednostkowo.

Open Source i dynamiczna społeczność: Grupa programistów aktywnie utrzymuje Flunt, co czyni go open-source. To gwarantuje ciągłe utrzymanie, ulepszenia i wsparcie dla frameworka.

Getting Started with Flunt C#

Konfiguracja Flunt w projektach C#

Przestrzenie nazw Notifications i Validation są częścią biblioteki Flunt Base Class Library i powinny być domyślnie dostępne w projekcie C#. Flunt przyspiesza walidację programów napisanych w języku C#, zapewniając elastyczny interfejs do definiowania i stosowania reguł walidacji. Obsługa czystszego kodu, zwiększona czytelność i kompleksowe obsługiwanie błędów ułatwiają sprawdzanie poprawności danych wprowadzanych przez użytkownika, obiektów domeny oraz żądań API.

Wdrażanie Flunt w konsoli Windows i Forms

Flunt jest wdrażany przez wiele typów aplikacji C#, w tym konsolę Windows, aplikacje internetowe i Windows Forms (WinForms). Chociaż każda platforma ma inną implementację, ogólna koncepcja jest zawsze taka sama.

Przykład Flunt C#

Możesz używać Flunt zaraz po jego zainstalowaniu. Oto prosty przykład pokazujący, jak używać Flunt do tworzenia reguł walidacji:

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

Imports System
Imports Flunt.Validations

Public Class Program
    Shared Sub Main(ByVal args As String())
        Dim person = New Person With {.Name = "Jack", .Age = -25}
        Dim contract = New PersonContract(person)

        ' Perform 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
        End If
    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)
        ' 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

Imports System
Imports Flunt.Validations

Public Class Program
    Shared Sub Main(ByVal args As String())
        Dim person = New Person With {.Name = "Jack", .Age = -25}
        Dim contract = New PersonContract(person)

        ' Perform 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
        End If
    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)
        ' 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 Klasa: Reprezentuje encję z właściwościami Name i Age.

PersonContract: Ta klasa pochodzi od fundamentalnej koncepcji Flunt Contract<t>. Używając metody Requires, konstruktor przyjmuje obiekt Person i dostarcza zasady walidacji. Requires oferuje możliwość zdefiniowania wielu walidacji w łańcuchu. Walidacje są przeprowadzane przez metody takie jak IsNotNull, IsNotEmpty, IsGreaterThan. Każda reguła walidacji ma przypisany niestandardowy komunikat o błędzie.

Walidacja: Podobnie jak w przykładzie FluentValidation, to tworzy instancję obiektu PersonContract i Person. Wyniki walidacji są pokazane przez atrybut kontraktu IsValid. Powiadomienia o powodzeniu lub niepowodzeniu, a także konkretne komunikaty o błędach, są wyświetlane w oparciu o wynik walidacji.

Operacje Flunt

W zakresie walidacji i obsługi powiadomień w aplikacjach C# Flunt oferuje wiele operacji, takich jak:

Tworzenie reguł walidacji: Aby utworzyć reguły walidacji dla atrybutów, takich jak pola obowiązkowe, typy danych, zakresy wartości, maksymalna długość i minimalna długość, należy użyć interfejsu fluent.

Przeprowadzanie walidacji: Aby zagwarantować integralność danych i zgodność z logiką biznesową, należy walidować obiekty pod kątem zdefiniowanych wcześniej reguł.

Postępowanie w przypadku błędów walidacji: Należy odnotowywać i rejestrować błędy walidacji jako alerty oraz reagować na nie w uprzejmy sposób, wyświetlając użytkownikom komunikaty o błędach lub rejestrując błędy w celu ich usunięcia.

Niestandardowa logika walidacji: Użyj unikalnych reguł walidacji, aby rozszerzyć Flunt w odpowiedzi na skomplikowane okoliczności walidacji lub szczególne wymagania domeny.

Integracja z frameworkami: Aby poprawić możliwości walidacji w obecnych aplikacjach, Flunt można płynnie zintegrować z wieloma znanymi frameworkami i bibliotekami .NET, w tym Entity Framework, ASP.NET Core i innymi.

Integracja Flunt z IronPDF

Programiści mogą wykorzystać zalety obu technologii, aby przyspieszyć walidację logiki biznesowej i tworzenie dokumentów w aplikacjach C# poprzez integrację Flunt z IronPDF. Programiści mogą zwiększyć niezawodność i przyjazność dla użytkownika aplikacji, wykorzystując IronPDF do tworzenia dokumentów PDF po zweryfikowaniu danych wejściowych za pomocą Flunt.

Zainstaluj IronPDF

• Uruchom projekt Visual Studio.
• Wybierz "Narzędzia" > "Menedżer pakietów NuGet" > "Konsola menedżera pakietów".
• Wpisz to polecenie w konsoli menedżera pakietów:

Install-Package IronPdf

• Alternatywnie można użyć menedżera pakietów NuGet dla rozwiązań, aby zainstalować IronPDF i inne niezbędne pakiety NuGet.
• Po przejrzeniu wyników wyszukiwania i wybraniu pakietu IronPDF kliknij przycisk "Zainstaluj". Instalacją i pobieraniem zajmie się Visual Studio.

• Instalacją pakietu IronPDF oraz wszelkich zależności niezbędnych dla projektu zajmie się NuGet.
• Po instalacji IronPDF jest gotowy do użycia w Twoim projekcie.

Zainstaluj za pośrednictwem strony internetowej NuGet

Aby dowiedzieć się więcej o funkcjach, kompatybilności i innych opcjach pobierania IronPDF, zajrzyj na stronę szczegółów pakietu NuGet na stronie NuGet.

Wykorzystaj bibliotekę DLL do instalacji

Alternatywnie można wykorzystać plik DLL IronPDF, aby włączyć go bezpośrednio do swojego projektu. Aby pobrać plik ZIP zawierający bibliotekę DLL, odwiedź następującą stronę pobierania plików ZIP IronPDF. Po rozpakowaniu biblioteki DLL należy dołączyć ją do projektu.

Wdrażanie logiki

Stwórzmy podstawową aplikację w języku C#, która wykorzystuje IronPDF do tworzenia plików PDF oraz Flunt do walidacji danych. W tym przykładzie użyjemy Flunt do walidacji danych wprowadzonych przez użytkownika w formularzu rejestracyjnym oraz IronPDF do utworzenia dokumentu PDF zawierającego podsumowanie zweryfikowanych danych użytkownika.

1. Klasa Person: Zdefiniowano klasę Person z atrybutami imienia i wieku. Weryfikujemy dane osoby pod kątem predefiniowanych reguł walidacji, wykorzystując płynny interfejs Flunta w konstruktorze.
2. Generowanie PDF: Zdefiniowana jest metoda o nazwie RenderHtmlAsPdf, która przyjmuje obiekt User jako dane wejściowe. Ta funkcja renderuje tekst HTML reprezentujący podsumowanie rejestracji użytkownika do dokumentu PDF używając klasy HtmlToPdf IronPDF.
3. Metoda Main: Korzystając z przykładowych danych klasy Person, tworzymy instancję klasy User w metodzie Main. Następnie używamy atrybutu IsValid Flunt, aby określić, czy dane osoby są prawidłowe. Aby utworzyć dokument PDF, wywołujemy metodę IronPDF, jeśli dane są poprawne. W przeciwnym razie problemy z walidacją zostaną wyświetlone w konsoli.

Opracowaliśmy szybki proces oceny danych wprowadzanych przez użytkownika i generowania dokumentów PDF w aplikacji C#, łącząc IronPDF do generowania plików PDF z Flunt do walidacji danych. Metoda ta zapewnia integralność danych, generuje dokumenty o profesjonalnej jakości oraz zachęca do pisania jasnego, czytelnego i łatwego w utrzymaniu kodu. Aby dowiedzieć się więcej o możliwościach IronPDF, zapoznaj się ze stroną dokumentacji. Poniżej znajduje się przykładowy fragment kodu.

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

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)
            ' StringBuilder for HTML content
            Dim sb As New StringBuilder()
            Dim person = New Person With {.Name = "Jack", .Age = -25}
            Dim contract = New PersonContract(person)

            If contract.IsValid Then
                Console.WriteLine("Person is valid!")
                sb.Append("<p>Person is valid!</p>")
            Else
                sb.Append("<p>Validation failed: </p>")
                For Each notification In contract.Notifications
                    sb.Append($"- {notification.Key}: {notification.Message}<br>")
                Next notification
            End If

            Dim renderer = New HtmlToPdf()
            ' Set HTML content for the page
            Dim 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!")
        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

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)
            ' StringBuilder for HTML content
            Dim sb As New StringBuilder()
            Dim person = New Person With {.Name = "Jack", .Age = -25}
            Dim contract = New PersonContract(person)

            If contract.IsValid Then
                Console.WriteLine("Person is valid!")
                sb.Append("<p>Person is valid!</p>")
            Else
                sb.Append("<p>Validation failed: </p>")
                For Each notification In contract.Notifications
                    sb.Append($"- {notification.Key}: {notification.Message}<br>")
                Next notification
            End If

            Dim renderer = New HtmlToPdf()
            ' Set HTML content for the page
            Dim 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!")
        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

Poniżej znajduje się wynik wykonania powyższego kodu:

Wnioski

IronPDF i Flunt to dwie potężne biblioteki C#, które dobrze ze sobą współpracują, usprawniając procesy tworzenia dokumentów i walidacji danych. Dzięki zaawansowanym funkcjom tworzenia plików PDF w IronPDF oraz rozbudowanym możliwościom walidacji w Flunt programiści mogą tworzyć niezawodne, skuteczne i wysokiej jakości rozwiązania dla różnych zastosowań. Flunt i IronPDF wyposażają programistów w narzędzia niezbędne do tworzenia wysokiej jakości oprogramowania, które spełnia potrzeby użytkowników i interesariuszy, niezależnie od tego, czy tworzą oni aplikacje desktopowe, aplikacje internetowe czy rozwiązania oparte na chmurze.

Rok wsparcia dla oprogramowania, licencja wieczysta i aktualizacja biblioteki są zawarte w pakiecie Lite $999. IronPDF udostępnia informacje o bezpłatnych licencjach IronPDF, zawierające szczegółowe dane dotyczące kosztów i wymagań licencyjnych. Aby uzyskać dodatkowe informacje na temat bibliotek Iron Software, odwiedź oficjalną stronę internetową Iron Software.