Flunt C# (Cómo funciona para desarrolladores)

Introducción

En el entorno actual de desarrollo de software, producir documentación de alto calibre y garantizar la integridad de los datos son tareas esenciales. En este post, veremos cómo combinar las potentes bibliotecas de C#, Flunt C#, y IronPDF para mejorar los flujos de trabajo de validación de datos y creación de documentos. Los desarrolladores pueden construir soluciones efectivas y confiables para una variedad de aplicaciones de software utilizando las características sofisticadas de producción de PDF de IronPDF y las fuertes capacidades de validación de Flunt.

Cómo utilizar Flunt en C#

1. Cree un nuevo proyecto de consola C#.

2. Instala el paquete Flunt desde Nuget.

3. Importa el espacio de nombres y hereda la clase.

4. Añade la validación al modelo de datos.

5. Realizar comprobaciones de validación y mostrar el resultado.

Comprensión de Flunt C#

El versátil y ligero framework .NET, Flunt, fue creado para facilitar el desarrollo de patrones de validación y notificación fluidos en aplicaciones C#. El código resulta más legible y se mantiene mejor cuando los desarrolladores utilizan Flunt para construir reglas de validación y lógica empresarial de forma fluida y expresiva. Con la amplia gama de técnicas de validación integradas y extensiones de Flunt, los desarrolladores pueden validar fácilmente estructuras de datos intrincadas como objetos y colecciones.

Además, Flunt es una herramienta útil para aumentar la fiabilidad y robustez de las aplicaciones de bibliotecas NET, ya que se integra fácilmente con las bases de código y los marcos de trabajo actuales. En definitiva, Flunt fomenta un enfoque declarativo de la validación y la gestión de errores, lo que permite a los desarrolladores escribir un código más limpio y robusto.

Características de Flunt C#

Interfaz Fluida: Flunt ofrece una interfaz legible y concisa para construir reglas de validación, lo que simplifica la expresión de la lógica de validación compleja.

Validación Enlazable: Los escenarios de validación enlazable se pueden crear con poco código al conectar las reglas de validación de forma natural.

Validadores Integrados: Flunt viene con varios validadores incorporados para tipos de datos utilizados con frecuencia, incluidos fechas, enteros, cadenas y colecciones. Una sintaxis fluida permite aplicar fácilmente estos validadores a las propiedades.

Reglas de Validación Personalizadas: Al expandir el marco Flunt, los desarrolladores pueden agregar reglas de validación personalizadas que permiten una lógica de validación adaptada a requisitos particulares del dominio.

Sistema de Notificaciones: Para reportar problemas de validación y recopilar mensajes de error, Flunt ofrece un sistema de notificaciones. Esto facilita a los desarrolladores la tarea de informar a los usuarios o a otros componentes de la aplicación de los fallos de validación.

Integración con Frameworks: Flunt se conecta fácilmente con frameworks y bibliotecas conocidas, incluyendo Entity Framework y ASP.NET Core, lo cual facilita añadir lógica de validación a proyectos ya existentes.

Testabilidad: Flunt facilita el desarrollo guiado por pruebas (TDD) al ofrecer una clara división entre el código de la aplicación y la lógica de validación, lo que simplifica la prueba unitaria de las reglas de validación.

Código Abierto y Comunidad próspera: Un grupo de desarrolladores mantiene Flunt activamente, haciéndolo de código abierto. Esto garantiza el mantenimiento, las mejoras y la asistencia continuos del marco.

Primeros pasos con Flunt C#

Configuración de Flunt en C# Proyectos

Los espacios de nombres Notifications y Validation forman parte de la biblioteca de clases base de Flunt y deberían estar accesibles por defecto en su proyecto C#. Flunt acelera la validación de programas C# proporcionando una interfaz flexible para definir y aplicar reglas de validación. Su compatibilidad con un código más limpio, una legibilidad mejorada y un tratamiento exhaustivo de los errores facilita la validación de las entradas de usuario, los objetos de dominio y las solicitudes de API.

Implementación de Flunt en Windows Console y Forms

Flunt es implementado por numerosos tipos de aplicaciones en C#, incluidas aplicaciones de consola de Windows, aplicaciones web y Windows Forms (WinForms). Aunque cada marco tiene una aplicación diferente, el concepto general es siempre el mismo.

Flunt C# Ejemplo

Puede utilizar el siguiente código Flunt tan pronto como se instala. Este es un ejemplo sencillo que muestra cómo utilizar Flunt para construir reglas de validación:

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 Clase: Lo mismo que en el ejemplo de FluentValidation.

PersonContract: Esta clase deriva del concepto fundamental de Flunt de Contract.Verifications. Usando el método Requires, el constructor toma un objeto Person y proporciona reglas de validación. Requires ofrece un método encadenable para agregar varias validaciones. Las validaciones se realizan mediante métodos como IsNotNull, NotEmpty, HasMinLength, y IsGreaterThan. Cada regla de validación dispone de mensajes de error personalizados.

Validación: Comparable al ejemplo de FluentValidation.Together con el objeto, crea una instancia de PersonContract y un objeto Person. El resultado de la validación se muestra mediante el atributo Valid del contrato. En función del resultado de la validación, se muestran notificaciones sobre el éxito o el fracaso, así como detalles concretos del error.

Operaciones Flunt

Para la validación y el manejo de notificaciones en aplicaciones C#, Flunt ofrece muchas operaciones, como:

Creación de reglas de validación: Para crear reglas de validación para atributos como campos obligatorios, tipos de datos, rangos de valores, longitud máxima y longitud mínima, utiliza la interfaz fluida.

Ejecución de la validación: Para garantizar la integridad de los datos y la adhesión a la lógica de negocio, validar objetos contra reglas predefinidas.

Gestión de errores de validación: Nota y registra los errores de validación como alertas y responde a ellos cortésmente proporcionando mensajes de error a los usuarios o registrando errores para la resolución de problemas. Lógica de validación personalizada Utilice reglas de validación únicas para ampliar Flunt en respuesta a circunstancias de validación intrincadas o requisitos de dominio particulares.

Integración con Frameworks: Para mejorar las capacidades de validación en las aplicaciones actuales, Flunt puede integrarse sin problemas con muchos frameworks y bibliotecas conocidas de .NET, incluyendo Entity Framework, ASP.NET Core, y más.

Integración de Flunt con IronPDF

Los desarrolladores pueden aprovechar los puntos fuertes de ambas tecnologías para agilizar la validación de la lógica empresarial y la creación de documentos en aplicaciones C# integrando Flunt con IronPDF. Los desarrolladores pueden hacer que las aplicaciones sean más fiables y fáciles de usar utilizando IronPDF para crear documentos PDF después de validar los datos de entrada con Flunt.

Instalar IronPDF

• Inicie el proyecto de Visual Studio.
• Seleccione "Herramientas" > "Gestor de paquetes NuGet" > "Consola del gestor de paquetes".
• Introduzca este comando en la consola del gestor de paquetes:

Install-Package IronPdf

• Como alternativa, puede utilizar NuGet Package Manager for Solutions para instalar IronPDF y otros paquetes NuGet necesarios.

• Haga clic en el botón "Instalar" después de explorar y elegir el paquete IronPDF en los resultados de la búsqueda. Visual Studio se encargará de la instalación y la descarga.

  

• La instalación del paquete IronPDF y de cualquier dependencia necesaria para su proyecto será gestionada por NuGet.
• Tras la instalación, IronPDF está disponible para ser utilizado en su proyecto.

Instalación a través del sitio web de NuGet

Para obtener más información sobre las características de IronPDF, su compatibilidad y otras opciones de descarga, consulte su página de detalles del paquete NuGet en el sitio web de NuGet.

Utilizar DLL para instalar

Como alternativa, puede utilizar el archivo DLL de IronPDF para incluirlo directamente en su proyecto. Para obtener el archivo ZIP que contiene la DLL, visite la siguiente página de descarga de IronPDF ZIP. Una vez descomprimida la DLL, inclúyela en tu proyecto.

Aplicación de la lógica

Vamos a crear una aplicación básica en C# que utilice IronPDF para la creación de PDF y Flunt para la validación de datos. En este ejemplo, utilizaremos Flunt para validar la entrada del usuario en un formulario de registro, e IronPDF para crear un documento PDF con un resumen de los datos del usuario que se han verificado.

1. Clase Persona: Se define una clase Persona con atributos para el nombre y la edad. Validamos los datos de Persona con reglas de validación predefinidas utilizando la interfaz fluida de Flunt en el constructor.

2. Generar Pdf: Se define un método llamado RenderHtmlAsPdf, y acepta un objeto User como entrada. Esta función convierte el texto HTML que representa el resumen de registro del usuario en un documento PDF utilizando la clase HtmlToPdf de IronPDF.

3. Método Principal: Usando datos de muestra de Persona, construimos una instancia de la clase Usuario en el método Principal. A continuación, usamos el atributo IsValid de Flunt para determinar si los datos de la persona son legítimos. Para crear el documento PDF, invocamos el método IronPdf si los datos son correctos. Si no, los problemas de validación se muestran en la consola.

   Hemos desarrollado un flujo de trabajo rápido para evaluar la entrada del usuario y producir documentos PDF en una aplicación C# combinando IronPDF para la generación de PDF con Flunt para la validación de datos. Este método garantiza la integridad de los datos, genera documentos de calidad experta y fomenta la redacción de código claro, legible y fácil de mantener. Para leer más sobre las capacidades de IronPDF, consulte la página de documentación. A continuación se muestra un fragmento de código de ejemplo.

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

A continuación se muestra la salida de ejecución del código anterior:

Conclusión

IronPDF y Flunt son dos potentes bibliotecas de C# que funcionan bien juntas para agilizar los flujos de trabajo de creación de documentos y validación de datos. Con las sofisticadas funciones de producción de PDF de IronPDF y las sólidas capacidades de validación de Flunt, los desarrolladores pueden construir soluciones fiables, eficaces y de gran calibre para una gran variedad de aplicaciones. Flunt e IronPDF dotan a los desarrolladores de las herramientas necesarias para crear software de alta calidad que satisfaga las necesidades de los usuarios y las partes interesadas, tanto si desarrollan aplicaciones de escritorio como aplicaciones web o soluciones basadas en la nube.

Un año de soporte de software, una licencia permanente y una actualización de biblioteca están incluidos en el paquete Lite $749. IronPDF proporciona detalles de licencia gratuita de IronPDF para obtener más información sobre el costo y los requisitos de licencia. Para obtener información adicional sobre las bibliotecas de Iron Software, visite el sitio web oficial de Iron Software.