Flunt C# (jak to działa dla programistów)

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.

Getting Started with Flunt C

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 As 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 notification
		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.

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 As 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.