Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
FluentValidation es una biblioteca de validación .NET que ayuda a crear reglas de validación fuertemente tipadas. Esto se consigue proporcionando una interfaz fluida y expresiones lambda, lo que hace que el código sea más legible y fácil de mantener. En lugar de utilizar anotaciones de datos o validación manual en sus clases modelo, puede utilizar Fluent Validation para crear una clase independiente para su lógica de validación.
Fluent Validation aporta más flexibilidad al juego de la validación. Con validadores integrados para escenarios comunes, la posibilidad de crear validaciones personalizadas y una forma sencilla de encadenar reglas de validación, Fluent Validation es una potente herramienta del conjunto de herramientas de .NET Core.
Fluent Validation es una biblioteca de código abierto para .NET que facilita la creación de reglas de validación para sus clases modelo.
AbstractValidator<T>
clase base.RuleFor
de una clase validadora.ValidationFailure
que contiene detalles sobre el error, incluyendo el nombre de la propiedad y el mensaje de error.IronPDF es una potente biblioteca .NET que le permite generar documentos PDF a partir de HTML contenido. Tanto si necesita crear facturas, informes o cualquier otro tipo de documento, IronPDF le ofrece una solución fácil de usar. Se integra perfectamente con sus aplicaciones ASP.NET Core, lo que le permite generar archivos PDF de alta calidad con sólo unas pocas líneas de código.
Ahora que ya sabemos qué son Fluent Validation y IronPDF, veamos cómo pueden utilizarse 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.
Ahora vamos a empezar!
Para empezar, vamos a crear una nueva aplicación de consola en Visual Studio o en su entorno de desarrollo preferido.
Seleccione "Consola App (ASP.NET Core)" como plantilla de proyecto e introduzca un nombre para su proyecto.
Crear una nueva aplicación de consola
Haga clic en el botón Siguiente y configure su proyecto dándole un nombre y seleccionando la ubicación del repositorio.
Configurar la nueva aplicación
Pulse el botón Siguiente y seleccione .NET Framework. El último .NET Framework (7) se recomienda.
Selección del .NET Framework
Una vez creado el proyecto, tenemos que añadir los paquetes NuGet necesarios para Fluent Validation y IronPDF.
Busque "FluentValidation" y haga clic en "Instalar" para añadir el paquete a su proyecto.
**Instale el paquete FluentValidation en la interfaz de usuario del gestor de paquetes NuGet
Del mismo modo, busque "IronPDF" e instale el paquete IronPDF.
Sin embargo, también puede instalar IronPDF mediante NuGet Package Manager Console utilizando el siguiente comando:
Install-Package IronPdf
Instale el paquete IronPdf en la consola del gestor de paquetes
Una vez configurado el proyecto e instalados los paquetes necesarios, pasemos a definir la clase de contenido PDF.
En este ejemplo, se creará un PDF de factura simple a partir de los códigos HTML de las dos nuevas clases: InvoiceContent
e InvoiceItem
.
public abstract class PdfContent
{
public abstract string RenderHtml();
}
public class InvoiceContent : PdfContent
{
public string CustomerName { get; set; }
public string Address { get; set; }
public List<InvoiceItem> InvoiceItems { get; set; }
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; }
}
public abstract class PdfContent
{
public abstract string RenderHtml();
}
public class InvoiceContent : PdfContent
{
public string CustomerName { get; set; }
public string Address { get; set; }
public List<InvoiceItem> InvoiceItems { get; set; }
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; }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
En el código anterior, se define una clase abstracta PdfContent
con un método abstracto llamado RenderHtml
. La clase InvoiceContent
extiende a PdfContent
y representa el contenido del PDF de la factura. Tiene propiedades para el nombre del cliente, la dirección y una lista de artículos de la factura. La clase InvoiceItem
contiene dos propiedades Description
y Price
. El método RenderHtml
genera el marcado HTML para la factura basándose en el contenido.
Ahora que el contenido del PDF está definido, pasemos a crear reglas de validación utilizando Fluent Validation.
Para construir reglas de validación para la clase InvoiceContent
, crea una clase validadora llamada InvoiceContentValidator
. Esta clase heredará de `AbstractValidator
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.");
}
}
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.");
}
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
En el código fuente anterior, se define la clase InvoiceContentValidator
, que hereda de AbstractValidator<InvoiceContent>
. Dentro del constructor de la clase validator, el método RuleFor
define reglas de validación para cada propiedad de la clase InvoiceContent
.
Por ejemplo, RuleFor(content => content.NombreCliente)
puede definir una nueva regla para que el nombre del cliente no esté vacío. Fluent Validation también puede encadenar el método NotEmpty
para especificar esta regla de validación. Del mismo modo, definimos reglas de validación para las propiedades de dirección y elementos de factura.
Para validar los elementos de la factura, se utiliza el método RuleForEach
para iterar sobre cada elemento de la lista InvoiceItems
y aplicar un validador llamado InvoiceItemValidator
. La clase InvoiceItemValidator
se define por separado y contiene reglas de validación para la clase InvoiceItem
.
Una vez establecidas estas reglas de validación, pasemos a generar el PDF con IronPDF.
IronPDF es una popular biblioteca .NET para crear y manipular documentos PDF. Se utilizará IronPDF para generar el PDF basándose en el contenido validado de la factura.
using IronPdf;
using FluentValidation;
public class PdfService
{
public PdfDocument GeneratePdf<T>(T content) where T : PdfContent
{
var validator = GetValidatorForContent(content);
FluentValidation.Results.ValidationResult validationResult = validator.Validate(content);
if (!validationResult.IsValid)
{
throw new FluentValidation.ValidationException(validationResult.Errors);
}
var renderer = new ChromePdfRenderer();
return renderer.RenderHtmlAsPdf(content.RenderHtml());
}
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.");
}
}
}
using IronPdf;
using FluentValidation;
public class PdfService
{
public PdfDocument GeneratePdf<T>(T content) where T : PdfContent
{
var validator = GetValidatorForContent(content);
FluentValidation.Results.ValidationResult validationResult = validator.Validate(content);
if (!validationResult.IsValid)
{
throw new FluentValidation.ValidationException(validationResult.Errors);
}
var renderer = new ChromePdfRenderer();
return renderer.RenderHtmlAsPdf(content.RenderHtml());
}
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.");
}
}
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
En el código fuente anterior, definimos una clase PdfService
que proporciona un método GeneratePdf
. Este método toma un objeto PdfContent
como entrada y genera el documento PDF basándose en el contenido validado.
Primero, recuperamos el validador apropiado para el contenido llamando al método GetValidatorForContent
. Este método comprueba el tipo de contenido y devuelve el validador correspondiente. En nuestro caso, sólo admitimos InvoiceContent
y utilizamos el InvoiceContentValidator
.
A continuación, validamos el contenido 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
)lanzamos una FluentValidation.ValidationException
con los errores de validación. En caso contrario, procedemos a generar el PDF utilizando IronPDF.
Creamos una instancia de Renderizador de PDF cromado para convertir el contenido HTML en PDF. Llamamos RenderHtmlAsPdf en el objeto htmlToPdf
y pasar el HTML generado por el método content.RenderHtml
. Esto genera el documento PDF.
Ahora que hemos definido la lógica de generación de PDF, vamos a gestionar los errores de validación que puedan producirse.
Cuando se produce un error de validación, queremos mostrar un mensaje de error y manejarlo con elegancia. Vamos a modificar el método Main
de la clase Program
para manejar cualquier excepción y mostrar mensajes significativos al usuario.
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
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);
}
}
}
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
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);
}
}
}
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
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 Class
En el código anterior, un bloque try-catch
ayuda a capturar cualquier excepción que pueda producirse. Si se captura una excepción, se mostrará un mensaje de error al usuario utilizando Console.WriteLine
.
Ahora, vamos a probar esta aplicación con diferentes escenarios para validar la generación de PDF y las reglas de validación.
En el ejemplo de código, hay tres escenarios para probar:
Generación correcta: Proporcione contenido válido para generar el PDF correctamente.
Ejecute la aplicación y observe 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 era de esperar, se muestran errores de validación para los dos primeros escenarios y un mensaje de éxito para el tercer escenario.
Este tutorial explora Fluent Validation y aprende a utilizarlo con IronPDF para generar documentos PDF. Empezando por configurar una aplicación de consola y definir la clase de contenido PDF. A continuación, creamos reglas de validación con Fluent Validation y probamos la generación de PDF con distintos escenarios.
Fluent Validation proporciona un enfoque flexible y fácil de usar para validar objetos en aplicaciones .NET. Le permite definir reglas de validación de una manera fuertemente tipada, personalizar los mensajes de error y manejar los errores de validación con gracia.
IronPDF ofrece un prueba gratuita y la licencia comienza a partir de $749.
9 productos API .NET para sus documentos de oficina