Cómo Usar Validación Fluent con IronPDF en C#

Entender la validación fluida

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.

1. Validadores: Los validadores son clases que encapsulan la lógica de validación. Normalmente se crean heredando de la clase base AbstractValidator<T>.
2. Reglas: Una regla es una condición de validación que una propiedad debe cumplir. Las reglas se definen usando el método RuleFor en una clase de validador.
3. 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.

Configuración del proyecto

Para empezar, crearemos una nueva Aplicación de Consola en Visual Studio o tu entorno de desarrollo preferido.

1. Abre Visual Studio y ve a Archivo > Nuevo > Proyecto.
2. 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

3. 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

4. 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

5. Haz clic en el botón Crear para crear el proyecto.

Instalar paquetes necesarios

Una vez creado el proyecto, añade los paquetes NuGet necesarios para Fluent Validation e IronPDF.

1. Haz clic derecho en el proyecto en el Explorador de Soluciones y selecciona "Gestionar Paquetes NuGet".
2. 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

3. 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:

Install-Package IronPdf

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.

Definición del contenido del PDF

En este ejemplo, se creará un PDF de factura simple a partir del código HTML en 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; }
}

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 Class

En 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 del PDF de la factura. 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 basado en el contenido.

Ahora que el contenido del PDF está definido, pasemos a crear reglas de validación usando Fluent Validation.

Creación de reglas de validación

Para construir reglas de validación para la clase InvoiceContent, crea una clase de validador llamada InvoiceContentValidator. Esta clase hereda de AbstractValidator<InvoiceContent>, que es proporcionada por 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.");
    }
}

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

En 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 artículo en 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.

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

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

La 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, soportamos InvoiceContent y usamos el InvoiceContentValidator.

Luego, el contenido es validado usando 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 una 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. El método RenderHtmlAsPdf se llama 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.

Manejo de errores de validación

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

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 Class

En el código anterior, se utilizan bloques try-catch para capturar cualquier excepción que pueda ocurrir. Si se captura una excepción, se mostrará un mensaje de error al usuario usando Console.WriteLine.

Ahora probemos esta aplicación con diferentes escenarios para validar la generación del PDF y las reglas de validación.

Probando la aplicación

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

1. Nombre del cliente vacío: Deja el nombre del cliente vacío para desencadenar un error de validación.
2. Artículos de factura vacíos: Proporciona una lista vacía de artículos de factura para desencadenar un error de validación.
3. Generación exitosa: Proporciona contenido válido para generar el PDF con éxito.

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.