Flunt C# (Cómo Funciona para Desarrolladores)

Cómo utilizar Flunt en C#;

1. Crea un nuevo proyecto de consola C#.
2. Instala el paquete Flunt desde NuGet.
3. Importa el namespace y hereda la clase.
4. Agrega la validación al modelo de datos.
5. Realiza comprobaciones de validación y muestra el resultado.

Comprensión de Flunt C#

El versátil y ligero marco .NET, Flunt, fue creado para facilitar el desarrollo de patrones de validación y notificación fluidos en aplicaciones C#. El código se torna más legible y mantenible cuando los desarrolladores usan Flunt para construir reglas de validación y lógica de negocio de manera 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 complejas como objetos y colecciones.

Además, Flunt es una herramienta útil para aumentar la confiabilidad y robustez de las aplicaciones de bibliotecas .NET ya que se integra fácilmente con bases de código y frameworks existentes. En resumen, Flunt fomenta un enfoque declarativo para la validación y el manejo de errores, permitiendo a los desarrolladores escribir código más limpio y robusto.

Cómo empezar con Flunt C#

Ejemplo de Flunt C

Puedes usar el siguiente código Flunt en cuanto esté instalado. Este es un ejemplo simple que te muestra cómo usar Flunt para construir reglas de validación:

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");
    }
}

Clase Person: Representa una entidad con propiedades Name y Age.

PersonContract: Esta clase deriva del concepto fundamental de Flunt de Contract. Usando el método Requires, el constructor toma un objeto Person y proporciona reglas de validación. Requires ofrece un método encadenable para definir múltiples validaciones. Las validaciones son realizadas por métodos como IsNotNull, IsNotEmpty, IsGreaterThan. Cada regla de validación tiene un mensaje de error personalizado asociado.

Validación: Similar a un ejemplo de FluentValidation, se crea una instancia de un PersonContract y un objeto Person. Los resultados de validación se muestran por el atributo IsValid del contrato. Notificaciones de éxito o fallo, así como mensajes de error específicos, se muestran basados en el resultado de la validación.

Operaciones Flunt

Para la validación y manejo de notificaciones en aplicaciones C#, Flunt ofrece muchas operaciones, tales 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 adherencia a la lógica de negocio, valida objetos contra reglas predefinidas.

Gestión de Errores de Validación: Nota y registra errores de validación como alertas y responde educadamente proporcionando a los usuarios mensajes de error o registrando errores para solucionar problemas.

Lógica de Validación Personalizada: Usa reglas de validación únicas para extender Flunt en respuesta a circunstancias de validación complejas o requisitos de dominio particulares.

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

Integración de Flunt con IronPDF

Los desarrolladores pueden aprovechar las fortalezas de ambas tecnologías para acelerar la validación de lógica de negocio y la creación de documentos en aplicaciones C# al integrar Flunt con IronPDF. Las aplicaciones pueden ser más confiables y amigables para el usuario al usar IronPDF para crear documentos PDF después de validar los datos de entrada con Flunt.

Instalar IronPDF

• Lanza el proyecto de Visual Studio.
• Selecciona "Herramientas" > "Administrador de Paquetes NuGet" > "Consola del Administrador de Paquetes".
• Introduce este comando en la Consola del Administrador de Paquetes:

Install-Package IronPdf

• Como alternativa, puedes usar el Administrador de Paquetes NuGet para Soluciones para instalar IronPDF y otros paquetes NuGet necesarios.
• Haz clic en el botón "Instalar" después de buscar y elegir el paquete de IronPDF de los resultados de búsqueda. La instalación y descarga serán gestionadas por Visual Studio.

• La instalación del paquete de IronPDF y cualquier dependencia necesaria para tu proyecto será gestionada por NuGet.
• Después de la instalación, IronPDF está disponible para su uso en tu proyecto.

Implementación de la lógica

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

1. Clase Person: Se define una clase Person con atributos de nombre y edad. Validamos los datos de la Persona contra reglas de validación predefinidas usando la interfaz fluida de Flunt en el constructor.
2. Generar Pdf: Se define un método llamado RenderHtmlAsPdf, y acepta un objeto Usuario como entrada. Esta función renderiza el texto HTML que representa el resumen del registro del usuario en un documento PDF usando la clase HtmlToPdf de IronPDF.
3. Método Principal: Usando datos de muestra de la 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 generar documentos PDF en una aplicación C# al combinar IronPDF para la generación de PDF con Flunt para la validación de datos. Este método asegura la integridad de los datos, genera documentos de calidad profesional y fomenta la escritura de código claro, legible y mantenible. Para leer más sobre las capacidades de IronPDF, consulta la página de documentación. A continuación, el 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 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");
        }
    }
}

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

Conclusión

IronPDF y Flunt son dos potentes bibliotecas C# que trabajan bien juntas para simplificar flujos de trabajo para la creación de documentos y validación de datos. Con las características sofisticadas de producción de PDF de IronPDF y las sólidas capacidades de validación de Flunt, los desarrolladores pueden construir soluciones confiables, efectivas y de alta calidad para una variedad de aplicaciones. Flunt e IronPDF equipan a los desarrolladores con las herramientas necesarias para crear software de alta calidad que satisface las necesidades de los usuarios y las partes interesadas, ya sea que estén desarrollando aplicaciones de escritorio, aplicaciones web o soluciones en la nube.

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