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

How to use Flunt in C

1. Utwórz nowy projekt konsoli C#.
2. Install the Flunt package from NuGet.
3. Import the namespace and inherit the class.
4. Add the validation to the data model.
5. Perform validation checks and display the result.

Understanding of Flunt C

The versatile and lightweight .NET framework, Flunt, was created to facilitate the development of fluent validation and notification patterns in C# applications. Code becomes more legible and maintained when developers use Flunt to construct validation rules and business logic in a fluid and expressive way. With Flunt's extensive range of integrated validation techniques and extensions, developers can easily validate intricate data structures like objects and collections.

Moreover, Flunt is a useful tool for boosting the dependability and robustness of .NET library applications since it easily integrates with current codebases and frameworks. All in all, Flunt encourages a declarative approach to validation and error handling, enabling developers to write cleaner, more robust code.

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 Class: Represents an entity with Name and Age properties.

PersonContract: This class derives from Flunt's fundamental concept of Contract<t>. Using the Requires method, the constructor takes a Person object and provides validation rules. Requires offers a chainable method for defining multiple validations. Validations are carried out by methods like IsNotNull, IsNotEmpty, IsGreaterThan. Każda reguła walidacji ma przypisany niestandardowy komunikat o błędzie.

Validation: Similar to a FluentValidation example, this creates an instance of a PersonContract and a Person object. The validation results are shown by the contract's IsValid attribute. Powiadomienia o powodzeniu lub niepowodzeniu, a także konkretne komunikaty o błędach, są wyświetlane w oparciu o wynik walidacji.

Flunt Operations

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. Generate Pdf: A method called RenderHtmlAsPdf is defined, and it accepts a User object as input. This function renders the HTML text representing the user registration summary into a PDF document by using IronPDF's HtmlToPdf class.
3. Metoda Main: Korzystając z przykładowych danych klasy Person, tworzymy instancję klasy User w metodzie Main. Next, we use Flunt's IsValid attribute to determine whether the Person data is legitimate. 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.

A year of software support, a permanent license, and a library upgrade are all included in the $799 Lite bundle. 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.