FluentValidation es una biblioteca de validación .NET que ayuda a construir reglas de validación fuertemente tipadas. Utiliza una interfaz fluida y expresiones lambda, haciendo el código más legible y mantenible. En lugar de usar anotaciones de datos o validación manual en tus clases de modelo, puedes usar Fluent Validation para construir una clase separada para tu lógica de validación.
Fluent Validation aporta más flexibilidad al juego de la validación. Con validadores integrados para escenarios comunes, la capacidad de crear validaciones personalizadas, y una forma sencilla de encadenar reglas de validación, Fluent Validation es una herramienta potente en el kit de herramientas .NET Core.
Fluent Validation es una biblioteca de código abierto para .NET que facilita la construcción de reglas de validación para tus clases de modelo.
AbstractValidator<t>.RuleFor en una clase de validador.ValidationFailure que contiene detalles sobre el error, incluido el nombre de la propiedad y el mensaje de error.IronPDF - Convertir HTML a PDF en C# es una biblioteca poderosa de .NET que te permite generar documentos PDF a partir de contenido HTML. Ya sea que necesites crear facturas, informes u otro tipo de documento, IronPDF proporciona una solución fácil de usar. Se integra perfectamente con tus aplicaciones ASP.NET Core, permitiéndote generar archivos PDF de alta calidad con solo unas pocas líneas de código.
Ahora que entendemos qué son Fluent Validation e IronPDF, veamos cómo pueden usarse juntos. Este tutorial ayudará a construir un generador de facturas, donde el contenido de la factura será validado usando FluentValidation en ASP.NET Core antes de generar el PDF usando IronPDF.
Para empezar, crearemos una nueva Aplicación de Consola en Visual Studio o tu entorno de desarrollo preferido.
Abre Visual Studio y ve a Archivo > Nuevo > Proyecto.
Selecciona "Aplicación de Consola (ASP.NET Core)" como la plantilla de proyecto y proporciona un nombre para tu proyecto.
Crear una nueva Aplicación de Consola
Haz clic en el botón Siguiente y configura tu proyecto nombrándolo y seleccionando la ubicación del repositorio.
Configurar la nueva aplicación
Haz clic en el botón Siguiente y selecciona el .NET Framework. Se recomienda el .NET Framework más reciente (7).
Selección del .NET Framework
Haz clic en el botón Crear para crear el proyecto.
Una vez creado el proyecto, añade los paquetes NuGet necesarios para Fluent Validation e IronPDF.
Haz clic derecho en el proyecto en el Explorador de Soluciones y selecciona "Gestionar Paquetes NuGet".
Busca "FluentValidation" y haz clic en "Instalar" para añadir el paquete a tu proyecto.
Instalar el paquete FluentValidation en la UI del Gestor de Paquetes NuGet
De manera similar, busca "IronPDF - Biblioteca PDF potente de .NET" e instala el paquete IronPDF.
Alternativamente, puedes instalar IronPDF usando Consola del Gestor de Paquetes NuGet con el siguiente comando:
Instalar el paquete IronPdf en la Consola del Gestor de Paquetes
Con el proyecto configurado y los paquetes requeridos instalados, pasemos a definir la clase de contenido PDF.
En este ejemplo, se creará una factura PDF simple a partir de los códigos HTML de dos clases: InvoiceContent y InvoiceItem.
using System.Collections.Generic;
using System.Linq;
public abstract class PdfContent
{
// Abstract method to generate the HTML string
public abstract string RenderHtml();
}
public class InvoiceContent : PdfContent
{
public string CustomerName { get; set; }
public string Address { get; set; }
public List<InvoiceItem> InvoiceItems { get; set; }
// Constructs the HTML representation of the invoice
public override string RenderHtml()
{
string invoiceItemsHtml = string.Join("", InvoiceItems.Select(item => $"<li>{item.Description}: {item.Price}</li>"));
return $"<h1>Invoice for {CustomerName}</h1><p>{Address}</p><ul>{invoiceItemsHtml}</ul>";
}
}
public class InvoiceItem
{
public string Description { get; set; }
public decimal Price { get; set; }
}Imports System.Collections.Generic
Imports System.Linq
Public MustInherit Class PdfContent
' Abstract method to generate the HTML string
Public MustOverride Function RenderHtml() As String
End Class
Public Class InvoiceContent
Inherits PdfContent
Public Property CustomerName() As String
Public Property Address() As String
Public Property InvoiceItems() As List(Of InvoiceItem)
' Constructs the HTML representation of the invoice
Public Overrides Function RenderHtml() As String
Dim invoiceItemsHtml As String = String.Join("", InvoiceItems.Select(Function(item) $"<li>{item.Description}: {item.Price}</li>"))
Return $"<h1>Invoice for {CustomerName}</h1><p>{Address}</p><ul>{invoiceItemsHtml}</ul>"
End Function
End Class
Public Class InvoiceItem
Public Property Description() As String
Public Property Price() As Decimal
End ClassEn el código anterior, se define una clase abstracta PdfContent con un método abstracto llamado RenderHtml. La clase InvoiceContent extiende PdfContent y representa el contenido de la factura PDF. Tiene propiedades para el nombre del cliente, dirección y una lista de artículos de factura. La clase InvoiceItem contiene dos propiedades: 'Descripción' y 'Precio'. El método RenderHtml genera el marcado HTML para la factura según el contenido.
Ahora que el contenido del PDF está definido, pasemos a crear reglas de validación usando Fluent Validation.
Para crear reglas de validación para la clase InvoiceContent, cree una clase validadora llamada InvoiceContentValidator. Esta clase heredará de AbstractValidator<InvoiceContent>, que proporciona FluentValidation.
using FluentValidation;
public class InvoiceContentValidator : AbstractValidator<InvoiceContent>
{
public InvoiceContentValidator()
{
RuleFor(content => content.CustomerName).NotEmpty().WithMessage("Customer name is required.");
RuleFor(content => content.Address).NotEmpty().WithMessage("Address is required.");
RuleFor(content => content.InvoiceItems).NotEmpty().WithMessage("At least one invoice item is required.");
RuleForEach(content => content.InvoiceItems).SetValidator(new InvoiceItemValidator());
}
}
public class InvoiceItemValidator : AbstractValidator<InvoiceItem>
{
public InvoiceItemValidator()
{
RuleFor(item => item.Description).NotEmpty().WithMessage("Description is required.");
RuleFor(item => item.Price).GreaterThanOrEqualTo(0).WithMessage("Price must be greater than or equal to 0.");
}
}Imports FluentValidation
Public Class InvoiceContentValidator
Inherits AbstractValidator(Of InvoiceContent)
Public Sub New()
RuleFor(Function(content) content.CustomerName).NotEmpty().WithMessage("Customer name is required.")
RuleFor(Function(content) content.Address).NotEmpty().WithMessage("Address is required.")
RuleFor(Function(content) content.InvoiceItems).NotEmpty().WithMessage("At least one invoice item is required.")
RuleForEach(Function(content) content.InvoiceItems).SetValidator(New InvoiceItemValidator())
End Sub
End Class
Public Class InvoiceItemValidator
Inherits AbstractValidator(Of InvoiceItem)
Public Sub New()
RuleFor(Function(item) item.Description).NotEmpty().WithMessage("Description is required.")
RuleFor(Function(item) item.Price).GreaterThanOrEqualTo(0).WithMessage("Price must be greater than or equal to 0.")
End Sub
End ClassEn el código fuente, se define la clase InvoiceContentValidator, que hereda de AbstractValidator<InvoiceContent>. Dentro del constructor de la clase validadora, el método RuleFor define reglas de validación para cada propiedad de la clase InvoiceContent.
Por ejemplo, RuleFor(content => content.CustomerName) especifica que el nombre del cliente no debe estar vacío. De manera similar, se definen reglas de validación para las propiedades de dirección y artículos de factura.
El método RuleForEach itera sobre cada elemento de la lista InvoiceItems y aplica el InvoiceItemValidator. La clase InvoiceItemValidator contiene reglas de validación para la clase InvoiceItem.
Con estas reglas de validación en su lugar, avancemos a la generación del PDF usando IronPDF.
IronPDF - Generar y Editar Documentos PDF es una biblioteca popular de .NET para crear y manipular documentos PDF. IronPDF se usará para generar el PDF basado en el contenido de la factura validado.
using IronPdf;
using FluentValidation;
public class PdfService
{
// Generates a PDF document for the provided content
public PdfDocument GeneratePdf<t>(T content) where T : PdfContent
{
// Validate the content using the appropriate validator
var validator = GetValidatorForContent(content);
var validationResult = validator.Validate(content);
// Check if validation is successful
if (!validationResult.IsValid)
{
throw new FluentValidation.ValidationException(validationResult.Errors);
}
// Generate the PDF using IronPDF
var renderer = new ChromePdfRenderer();
return renderer.RenderHtmlAsPdf(content.RenderHtml());
}
// Retrieves the appropriate validator for the content
private IValidator<t> GetValidatorForContent<t>(T content) where T : PdfContent
{
if (content is InvoiceContent)
{
return (IValidator<t>)new InvoiceContentValidator();
}
else
{
throw new NotSupportedException("Unsupported content type.");
}
}
}Imports IronPdf
Imports FluentValidation
Public Class PdfService
' Generates a PDF document for the provided content
Public Function GeneratePdf(Of T As PdfContent)(content As T) As PdfDocument
' Validate the content using the appropriate validator
Dim validator = GetValidatorForContent(content)
Dim validationResult = validator.Validate(content)
' Check if validation is successful
If Not validationResult.IsValid Then
Throw New FluentValidation.ValidationException(validationResult.Errors)
End If
' Generate the PDF using IronPDF
Dim renderer = New ChromePdfRenderer()
Return renderer.RenderHtmlAsPdf(content.RenderHtml())
End Function
' Retrieves the appropriate validator for the content
Private Function GetValidatorForContent(Of T As PdfContent)(content As T) As IValidator(Of T)
If TypeOf content Is InvoiceContent Then
Return CType(New InvoiceContentValidator(), IValidator(Of T))
Else
Throw New NotSupportedException("Unsupported content type.")
End If
End Function
End ClassLa clase PdfService proporciona un método GeneratePdf. Este método toma un objeto PdfContent como entrada y genera el documento PDF basado en el contenido validado.
Primero, recupera el validador apropiado para el contenido llamando al método GetValidatorForContent, que verifica el tipo de contenido y devuelve el validador correspondiente. En nuestro caso, admitimos InvoiceContent y utilizamos InvoiceContentValidator.
A continuación, el contenido se valida utilizando el validador llamando a su método Validate. El resultado de la validación se almacena en un objeto ValidationResult.
Si la validación falla (!validationResult.IsValid), se lanza un FluentValidation.ValidationException con los errores de validación. De lo contrario, el PDF se genera usando IronPDF.
Se crea una instancia de ChromePdfRenderer para renderizar el contenido HTML como un PDF. Se llama al método RenderHtmlAsPdf en el objeto renderer, pasando el HTML generado por el método content.RenderHtml, generando el documento PDF.
Ahora que hemos definido la lógica de generación de PDF, manejemos cualquier error de validación que pueda ocurrir.
Cuando ocurre un error de validación, queremos mostrar un mensaje de error y manejarlo de manera adecuada. Modifiquemos el método Main de la clase Program para manejar cualquier excepción y mostrar mensajes significativos al usuario.
using System;
using System.Collections.Generic;
public class Program
{
static void Main(string[] args)
{
var pdfService = new PdfService();
// Test 1: Empty Customer Name
try
{
var invoiceContent = new InvoiceContent
{
CustomerName = "",
Address = "123 Main St, Anytown, USA",
InvoiceItems = new List<InvoiceItem> {
new InvoiceItem { Description = "Item 1", Price = 19.99M },
new InvoiceItem { Description = "Item 2", Price = 29.99M }
}
};
var pdfDocument = pdfService.GeneratePdf(invoiceContent);
pdfDocument.SaveAs("C:\\TestInvoice.pdf");
Console.WriteLine("PDF generated successfully!");
}
catch (Exception ex)
{
Console.WriteLine("Error generating PDF: " + ex.Message);
}
// Test 2: Empty InvoiceItems
try
{
var invoiceContent = new InvoiceContent
{
CustomerName = "John Doe",
Address = "123 Main St, Anytown, USA",
InvoiceItems = new List<InvoiceItem>() // Empty list
};
var pdfDocument = pdfService.GeneratePdf(invoiceContent);
pdfDocument.SaveAs("C:\\TestInvoice.pdf");
Console.WriteLine("PDF generated successfully!");
}
catch (Exception ex)
{
Console.WriteLine("Error generating PDF: " + ex.Message);
}
// Successful generation
try
{
var invoiceContent = new InvoiceContent
{
CustomerName = "John Doe",
Address = "123 Main St, Anytown, USA",
InvoiceItems = new List<InvoiceItem> {
new InvoiceItem { Description = "Item 1", Price = 19.99M },
new InvoiceItem { Description = "Item 2", Price = 29.99M }
}
};
var pdfDocument = pdfService.GeneratePdf(invoiceContent);
pdfDocument.SaveAs("C:\\TestInvoice.pdf");
Console.WriteLine("PDF generated successfully!");
}
catch (Exception ex)
{
Console.WriteLine("Error generating PDF: " + ex.Message);
}
}
}Imports System
Imports System.Collections.Generic
Public Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfService As New PdfService()
' Test 1: Empty Customer Name
Try
Dim invoiceContent As New InvoiceContent With {
.CustomerName = "",
.Address = "123 Main St, Anytown, USA",
.InvoiceItems = New List(Of InvoiceItem) From {
New InvoiceItem With {
.Description = "Item 1",
.Price = 19.99D
},
New InvoiceItem With {
.Description = "Item 2",
.Price = 29.99D
}
}
}
Dim pdfDocument = pdfService.GeneratePdf(invoiceContent)
pdfDocument.SaveAs("C:\TestInvoice.pdf")
Console.WriteLine("PDF generated successfully!")
Catch ex As Exception
Console.WriteLine("Error generating PDF: " & ex.Message)
End Try
' Test 2: Empty InvoiceItems
Try
Dim invoiceContent As New InvoiceContent With {
.CustomerName = "John Doe",
.Address = "123 Main St, Anytown, USA",
.InvoiceItems = New List(Of InvoiceItem)()
}
Dim pdfDocument = pdfService.GeneratePdf(invoiceContent)
pdfDocument.SaveAs("C:\TestInvoice.pdf")
Console.WriteLine("PDF generated successfully!")
Catch ex As Exception
Console.WriteLine("Error generating PDF: " & ex.Message)
End Try
' Successful generation
Try
Dim invoiceContent As New InvoiceContent With {
.CustomerName = "John Doe",
.Address = "123 Main St, Anytown, USA",
.InvoiceItems = New List(Of InvoiceItem) From {
New InvoiceItem With {
.Description = "Item 1",
.Price = 19.99D
},
New InvoiceItem With {
.Description = "Item 2",
.Price = 29.99D
}
}
}
Dim pdfDocument = pdfService.GeneratePdf(invoiceContent)
pdfDocument.SaveAs("C:\TestInvoice.pdf")
Console.WriteLine("PDF generated successfully!")
Catch ex As Exception
Console.WriteLine("Error generating PDF: " & ex.Message)
End Try
End Sub
End ClassEn el código anterior, se utilizan bloques try-catch para capturar cualquier excepción que pueda ocurrir. Si se detecta una excepción, se mostrará un mensaje de error al usuario mediante Console.WriteLine.
Ahora probemos esta aplicación con diferentes escenarios para validar la generación del PDF y las reglas de validación.
En el ejemplo de código, hay tres escenarios para probar:
Ejecuta la aplicación y observa la salida en la consola.
Error generating PDF: Validation failed:
-- CustomerName: Customer name is required. Severity: Error
Error generating PDF: Validation failed:
-- InvoiceItems: At least one invoice item is required. Severity: Error
PDF generated successfully!
El error de salida en la consola
El archivo PDF de salida
Como se esperaba, se muestran errores de validación para los primeros dos escenarios y un mensaje de éxito para el tercer escenario.
Este tutorial exploró Fluent Validation y cómo usarlo con IronPDF para generar documentos PDF. Comenzando configurando una Aplicación de Consola y definiendo la clase de contenido PDF. Luego, creamos reglas de validación usando Fluent Validation y probamos la generación de PDF con diferentes escenarios.
Fluent Validation proporciona un enfoque flexible y fácil de usar para validar objetos en aplicaciones .NET. Te permite definir reglas de validación de manera fuertemente tipada, personalizar mensajes de error y manejar los errores de validación de manera adecuada.
IronPDF Free Trial & Licensing Information ofrece una prueba gratuita, y la licencia comienza desde $499 por desarrollador.
Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.
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.
