Flunt C# (How It Works For Developers)

Introduction

In the current software development environment, producing high-caliber documentation and guaranteeing data integrity are essential tasks. In this post, we'll look at how to combine the potent C# libraries, Flunt C#, and IronPDF to improve workflows for data validation and document creation. Developers can construct effective and dependable solutions for a variety of applications by utilizing IronPDF's sophisticated PDF production features and Flunt's strong validation capabilities.

How to use Flunt in C#

1. Create a new C# console project.
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.

Features of Flunt C#

Fluent Interface: Flunt offers a legible and succinct interface for building validation rules, which simplifies the expression of complex validation logic.

Chainable Validation: Chainable validation scenarios can be created with little code by connecting validation rules naturally.

Integrated Validators: Flunt comes with several built-in validators for frequently used data types, including dates, integers, strings, and collections. Fluent syntax allows for the easy application of these validators to properties.

Custom Validation Rules: By expanding the Flunt framework, developers can add custom validation rules that allow validation logic adapted to particular domain requirements.

Notification System: To report validation issues and gather error messages, Flunt offers a notification system. This makes it simple for developers to inform users or other application components of validation failures.

Integration with Frameworks: Flunt easily connects with well-known frameworks and libraries, including Entity Framework and ASP.NET Core, making it simple to add validation logic to already-existing projects.

Testability: Flunt facilitates test-driven development (TDD) by offering a distinct division between application code and validation logic, making it simple to unit test validation rules.

Open Source and thriving Community: A group of developers actively maintains Flunt, making it open-source. This guarantees continued maintenance, enhancements, and support for the framework.

Getting Started with Flunt C#

Setting Up Flunt in C# Projects

The Notifications and Validation namespace are part of the Flunt Base Class Library and should be accessible by default in your C# project. Flunt accelerates validation for C# programs by providing a flexible interface for defining and applying validation rules. Its support for cleaner code, enhanced readability, and thorough error handling makes validating user input, domain objects, and API requests easier.

Implementing Flunt in Windows console and forms

Flunt is implemented by numerous C# application types, including Windows Console, web applications, and Windows Forms (WinForms). Although each framework has a different implementation, the general concept is always the same.

Flunt C# example

You can use the following code Flunt as soon as it's installed. This is a simple example that shows you how to use Flunt to construct validation rules:

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 Class: The same as in the example of FluentValidation.

PersonContract: This class derives from Flunt's fundamental concept of Contract.Verifications. Using the Requires method, the constructor takes a Person object and provides validation rules. Requires offers a chainable method for adding several validations. Validations are carried out by methods like IsNotNull, NotEmpty, HasMinLength, and IsGreaterThan. With every validation rule, there are personalized error messages available.

Validation: Comparable to the example of FluentValidation.Together with the object, it creates a PersonContract instance and a Person object. The validation outcome is shown by the contract's Valid attribute. Depending on the validation result, notifications about success or failure as well as particular error details are shown.

Flunt Operations

For validation and notification handling in C# applications, Flunt offers many operations, such as:

Creating Validation Rules: To create validation rules for attributes like mandatory fields, data types, value ranges, maximum length, and minimum length, use the fluent interface.

Executing Validation: To guarantee data integrity and adherence to business logic, validate objects against predefined rules.

Managing Validation Mistakes: Note and record validation mistakes as alerts and respond to them politely by giving users error messages or recording errors for troubleshooting. Personalized Validation Logic Use unique validation rules to extend Flunt in response to intricate validation circumstances or particular domain requirements.

Integration with Frameworks: To improve validation capabilities in current applications, Flunt may be seamlessly integrated with many well-known.NET frameworks and libraries, including Entity Framework, ASP.NET Core, and more.

Integrating Flunt with IronPDF

Developers can harness the strengths of both technologies to expedite business logic validation and document creation in C# applications by integrating Flunt with IronPDF. Applications can be made more dependable, dependable, and user-friendly by developers by using IronPDF to create PDF documents after validating input data with Flunt.

Install IronPDF

• Launch the Visual Studio project.
• Select "Tools" > "NuGet Package Manager" > "Package Manager Console".
• Input this command into the Package Manager Console:

Install-Package IronPdf

• As an alternative, you can use NuGet Package Manager for Solutions to install IronPDF and other necessary NuGet Packages.

• Click the "Install" button after exploring and choosing the IronPDF package from the search results. The installation and download will be taken care of by Visual Studio.

  

• Installing the IronPDF package and any dependencies needed for your project will be handled by NuGet.
• After installation, IronPDF is available for use in your project.

Install Through the NuGet Website

To find out more about IronPDF's features, compatibility, and other download choices, see its page at https://www.nuget.org/packages/IronPdf on the NuGet website.

Utilize DLL to Install

As an alternative, you can utilize IronPDF's DLL file to include it straight into your project. To obtain the ZIP file containing the DLL, visit the following link. Once the DLL has been unzipped, include it in your project.

Implementing Logic

Let's create a basic C# application that uses IronPDF for PDF creation and Flunt for data validation. In this example, we will use Flunt to validate user input for a registration form, and IronPDF to create a PDF document with a summary of the user data that has been verified.

1. Person Class: A Person class with attributes for name and age is defined. We validate the Person data against predefined validation rules by using Flunt's fluent interface in the constructor.
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. Main Method: Using sample Person data, we build an instance of the User class in the Main method. Next, we use Flunt's IsValid attribute to determine whether the Person data is legitimate. To create the PDF document, we invoke the IronPdf method if the data is correct. If not, the validation problems are shown on the console.

We have developed a fast workflow for evaluating user input and producing PDF documents in a C# application by combining IronPDF for PDF generation with Flunt for data validation. This method ensures data integrity, generates papers of expert quality, and encourages the writing of clear, readable, and maintainable code. To read more about IronPDF, refer here. Below is the sample code snippet.

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

Below is the execution output from the above code:

Conclusion

IronPDF and Flunt are two strong C# libraries that work well together to streamline workflows for document creation and data validation. With IronPDF's sophisticated PDF production features and Flunt's strong validation capabilities, developers can construct dependable, effective, and high-caliber solutions for a variety of applications. Flunt and IronPDF equip developers with the tools necessary to create high-quality software that meets the needs of users and stakeholders, whether they are developing desktop apps, web applications, or cloud-based solutions.

A year of software support, a permanent license, and a library upgrade are all included in the $749 Lite bundle. IronPDF provides free licensing of IronPDF for further details regarding cost and license requirements. For additional information about the Iron Software libraries, visit this website.