En el entorno actual de desarrollo de software, producir documentación de alta calidad y garantizar la integridad de los datos son tareas esenciales. En esta publicación, veremos cómo combinar las potentes bibliotecas C#, Flunt C# e 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 al utilizar las características sofisticadas de producción de PDF de IronPDF y las sólidas capacidades de validación de Flunt.
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.
Interfaz Fluida: Flunt ofrece una interfaz legible y concisa para construir reglas de validación, lo que simplifica la expresión de lógica de validación compleja.
Validación Encadenable: Se pueden crear escenarios de validación encadenados con poco código al conectar reglas de validación naturalmente.
Validadores Integrados: Flunt viene con varios validadores integrados para tipos de datos frecuentemente usados, incluyendo fechas, enteros, cadenas y colecciones. La sintaxis fluida permite la fácil aplicación de 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 de dominio particulares.
Sistema de Notificaciones: Para reportar problemas de validación y reunir mensajes de error, Flunt ofrece un sistema de notificaciones. Esto hace sencillo para los desarrolladores informar a los usuarios o a otros componentes de la aplicación sobre fallos de validación.
Integración con Frameworks: Flunt se conecta fácilmente con frameworks y bibliotecas bien conocidas, incluyendo Entity Framework y ASP.NET Core, lo que hace sencillo añadir lógica de validación a proyectos ya existentes.
Testabilidad: Flunt facilita el desarrollo dirigido por pruebas (TDD) al ofrecer una división clara entre el código de aplicación y la lógica de validación, haciendo sencillo realizar pruebas unitarias de las reglas de validación.
Código Abierto y una Comunidad Próspera: Un grupo de desarrolladores mantiene activamente Flunt, haciéndolo de código abierto. Esto garantiza mantenimientos continuos, mejoras y soporte para el marco.
Los namespaces de Notificaciones y Validación son parte de la Biblioteca de Clases Base de Flunt y deberían ser accesibles por defecto en tu proyecto C#. Flunt acelera la validación para programas C# al proporcionar una interfaz flexible para definir y aplicar reglas de validación. Su soporte para código más limpio, legibilidad mejorada y manejo exhaustivo de errores hace más fácil validar la entrada del usuario, objetos de dominio y solicitudes API.
Flunt es implementado por numerosos tipos de aplicaciones C#, incluyendo la Consola de Windows, aplicaciones web y Formularios Windows (WinForms). Aunque cada framework tiene una implementación diferente, el concepto general siempre es el mismo.
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");
}
}Imports System
Imports Flunt.Validations
Public Class Program
Shared Sub Main(ByVal args As String())
Dim person = 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
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 ClassPerson Clase: Representa una entidad con propiedades Name y Age.
PersonContract: Esta clase deriva del concepto fundamental de Contract<t> de Flunt. Utilizando 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 se realizan mediante 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, esto crea una instancia de un PersonContract y un objeto Person. Los resultados de la validación se muestran mediante 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.
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.
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.
Para saber más sobre las características de IronPDF, compatibilidad y otras opciones de descarga, consulta su página de detalles del paquete NuGet en el sitio web de NuGet.
Como alternativa, puedes utilizar el archivo DLL de IronPDF para incluirlo directamente en tu proyecto. Para obtener el archivo ZIP que contiene el DLL, visita la siguiente página de descarga del ZIP de IronPDF. Una vez que el DLL se haya descomprimido, inclúyelo en tu proyecto.
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.
RenderHtmlAsPdf, que acepta un objeto Usuario como entrada. Esta función representa el texto HTML que representa el resumen del registro de usuario en un documento PDF utilizando la clase HtmlToPdf de IronPDF.IsValid de Flunt para determinar si los datos de la Persona son legítimos. Para crear el documento PDF, invocamos el método de 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");
}
}
}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 = 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 NamespaceA continuación se muestra el resultado de la ejecución del código anterior:
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 $999. 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.
Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
