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 crear soluciones eficaces y fiables para una gran variedad de productos aplicaciones utilizando las sofisticadas funciones de producción de PDF de IronPDF y las potentes 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 sucinta para construir reglas de validación, lo que simplifica la expresión de lógicas de validación complejas.

Validación encadenable: Se pueden crear escenarios de validación encadenables con poco código conectando reglas de validación de forma natural.

Validadores integrados: Flunt viene con varios validadores integrados para tipos de datos de uso frecuente, incluyendo fechas, enteros, cadenas y colecciones. Una sintaxis fluida permite aplicar fácilmente estos validadores a las propiedades.

Reglas de validación personalizadas: Al ampliar el marco de trabajo de Flunt, los desarrolladores pueden añadir reglas de validación personalizadas que permiten una lógica de validación adaptada a requisitos de dominio particulares.

Sistema de notificación: Para informar de problemas de validación y recopilar mensajes de error, Flunt ofrece un sistema de notificación. 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 bien conocidos, incluidos Entity Framework y ASP.NET Core, lo que simplifica la adición de lógica de validación a proyectos ya existentes.

**Comprobabilidad: Flunt facilita el desarrollo basado en pruebas. (TDD) al ofrecer una división clara entre el código de la aplicación y la lógica de validación, lo que simplifica las pruebas unitarias de las reglas de validación.

Fuente abierta y comunidad próspera: Un grupo de desarrolladores mantiene activamente Flunt, convirtiéndolo en 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 la consola y formularios de Windows

Flunt se implementa en numerosos tipos de aplicaciones C#, como la consola de Windows, las 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

Clase Persona: La misma que en el ejemplo de FluentValidation.

PersonContract: Esta clase deriva del concepto fundamental de Flunt Contract.Verifications. Mediante el método Requires, el constructor toma un objeto Person y proporciona reglas de validación. Requires ofrece un método encadenable para añadir 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.Junto con el objeto, crea una instancia de PersonContract y un objeto Persona. 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, utilice la interfaz fluent.

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: Anote y registre los errores de validación como alertas y responda a ellos amablemente dando a los usuarios mensajes de error o registrando los 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 perfectamente con muchos frameworks y bibliotecas .NET conocidos, incluidos Entity Framework, ASP.NET Core, etc.

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, seguras y fáciles de usar utilizando IronPDF para crear documentos PDF tras 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 en https://www.nuget.org/packages/IronPdf 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 dirección enlace. 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 nombre y 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, que 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 ejemplo de Persona, construimos una instancia de la clase Usuario en el método Principal. A continuación, utilizamos el atributo IsValid de Flunt para determinar si los datos de 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 obtener más información sobre IronPDF, consulte aquí. 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.

El paquete Lite $749 incluye un año de soporte de software, una licencia permanente y una actualización de la biblioteca. IronPDF ofrece licencias gratuitas de IronPDF para más detalles sobre el coste y los requisitos de licencia. Para obtener más información sobre las bibliotecas de Iron Software, visite este enlace sitio web.