USO DE IRONPDF

Cómo utilizar Fluent Validation con IronPDF en C#

Actualizado 27 de junio, 2023

¿Qué es la validación fluente?

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.

Comprender la validación de Fluent

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.

Validadores: Los validadores son clases que encapsulan la lógica de validación. Normalmente se crean heredando de AbstractValidator<T> clase base.
Reglas: Una regla es una condición de validación que debe cumplir una propiedad. Las reglas se definen mediante el método RuleFor de una clase validadora.
Fallos de validación: Si una regla falla, Fluent Validation crea un objeto ValidationFailure que contiene detalles sobre el error, incluyendo el nombre de la propiedad y el mensaje de error.

¿Qué es IronPDF?

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.

Uso de Fluent Validation con IronPDF

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!

Configuración del proyecto

Para empezar, vamos a crear una nueva aplicación de consola en Visual Studio o en su entorno de desarrollo preferido.

Abra Visual Studio y vaya a Archivo > Nuevo > Proyecto.
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 marco .NET**
```
Haga clic en el botón Crear para crear el proyecto.

Instalar los paquetes necesarios

Una vez creado el proyecto, tenemos que añadir los paquetes NuGet necesarios para Fluent Validation y IronPDF.

Haga clic con el botón derecho en el proyecto en el Explorador de soluciones y seleccione "Administrar paquetes NuGet".

Busque "FluentValidation" y haga clic en "Instalar" para añadir el paquete a su proyecto.

Cómo utilizar Fluent Validation con IronPDF en C#, Figura 4: Instalación del paquete FluentValidation en la interfaz de usuario del gestor de paquetes NuGet

 **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

Cómo utilizar Fluent Validation con IronPDF en C#, Figura 5: Instalar el paquete IronPdf en la consola del gestor de paquetes

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.

Definir el contenido del 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; }
}

Public MustInherit Class PdfContent
	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)

	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 Class

VB C#

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.

Creación de reglas de validación

Para construir reglas de validación para la clase InvoiceContent, crea una clase validadora llamada InvoiceContentValidator. Esta clase heredará de `AbstractValidatorque proporciona Fluent Validation.

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

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 Class

VB C#

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.

Generación de 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.");
        }
    }
}

Imports IronPdf
Imports FluentValidation

Public Class PdfService
	Public Function GeneratePdf(Of T As PdfContent)(ByVal content As T) As PdfDocument
		Dim validator = GetValidatorForContent(content)
		Dim validationResult As FluentValidation.Results.ValidationResult = validator.Validate(content)

		If Not validationResult.IsValid Then
			Throw New FluentValidation.ValidationException(validationResult.Errors)
		End If

		Dim renderer = New ChromePdfRenderer()
		Return renderer.RenderHtmlAsPdf(content.RenderHtml())
	End Function

	Private Function GetValidatorForContent(Of T As PdfContent)(ByVal content As T) As IValidator(Of T)
		If TypeOf content Is InvoiceContent Then
			Return DirectCast(New InvoiceContentValidator(), IValidator(Of T))
		Else
			Throw New NotSupportedException("Unsupported content type.")
		End If
	End Function
End Class

VB C#

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.

Tratamiento de errores de validación

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();

        //  Prueba 1: Nombre de cliente vacío
        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);
        }

        //  Prueba 2: InvoiceItems vacíos
        try
        {
            var invoiceContent = new InvoiceContent
            {
                CustomerName = "John Doe",
                Address = "123 Main St, Anytown, USA",
                InvoiceItems = new List<InvoiceItem>()  //  Lista vacía
            };

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

        //Éxito
        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();

        //  Prueba 1: Nombre de cliente vacío
        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);
        }

        //  Prueba 2: InvoiceItems vacíos
        try
        {
            var invoiceContent = new InvoiceContent
            {
                CustomerName = "John Doe",
                Address = "123 Main St, Anytown, USA",
                InvoiceItems = new List<InvoiceItem>()  //  Lista vacía
            };

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

        //Éxito
        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()

		'  Prueba 1: Nombre de cliente vacío
		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

		'  Prueba 2: InvoiceItems vacíos
		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

		'Éxito
		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

VB C#

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.

Probar la aplicación

En el ejemplo de código, hay tres escenarios para probar:

Nombre de cliente vacío: Deje el nombre de cliente vacío para activar un error de validación.
Elementos de factura vacíos: Se proporciona una lista vacía de partidas de factura para provocar un error de validación.
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!

Cómo utilizar la validación fluida con IronPDF en C#, Figura 6: El error de salida en la consola

El error de salida en la Consola

Cómo utilizar Fluent Validation con IronPDF en C#, Figura 7: El archivo PDF de salida

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.

Conclusión

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.

< ANTERIOR
PDF frente a PDFA (cómo funciona para los desarrolladores)

SIGUIENTE >
Cómo utilizar ChatGPT con IronPDF para desarrolladores C#