Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
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.
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.
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.
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.
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.
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.
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.
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.
Install-Package IronPdf
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.
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.
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.
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.
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.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:
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.
9 productos API .NET para sus documentos de oficina