Como usar a validação fluente com o IronPDF em C#

Entendendo a Validação Fluente

Fluent Validation é uma biblioteca de código aberto for .NET que facilita a criação de regras de validação para suas classes de modelo.

1. Validadores: Os validadores são classes que encapsulam a lógica de validação. Eles são normalmente criados por herança da classe base AbstractValidator<t>.
2. Regras: Uma regra é uma condição de validação que uma propriedade deve atender. As regras são definidas usando o método RuleFor em uma classe validadora.
3. Falhas de Validação: Se uma regra falhar, o Fluent Validation cria um objeto ValidationFailure que contém detalhes sobre o erro, incluindo o nome da propriedade e a mensagem de erro.

Configurando o projeto

Para começar, vamos criar um novo aplicativo de console no Visual Studio ou no seu ambiente de desenvolvimento preferido.

1. Abra o Visual Studio e vá para Arquivo > Novo > Projeto .

2. Selecione "Aplicativo de console (ASP.NET Core)" como modelo de projeto e forneça um nome para o seu projeto.

   Criar um novo aplicativo de console

3. Clique no botão Próximo e configure seu projeto, dando-lhe um nome e selecionando o local do repositório.

   Configure o novo aplicativo

4. Clique no botão Avançar e selecione o .NET Framework. Recomenda-se a versão mais recente do .NET Framework (7).

   Seleção do .NET Framework

5. Clique no botão Criar para criar o projeto.

Instale os pacotes necessários

Após a criação do projeto, adicione os pacotes NuGet necessários para o Fluent Validation e o IronPDF.

1. Clique com o botão direito do mouse no projeto no Solution Explorer e selecione "Gerenciar Pacotes NuGet ".

2. Procure por "FluentValidation" e clique em "Instalar" para adicionar o pacote ao seu projeto.

   Instale o pacote FluentValidation na interface do Gerenciador de Pacotes NuGet.

3. Da mesma forma, pesquise por " IronPDF - Powerful .NET PDF Library " e instale o pacote IronPDF .

Alternativamente, você pode instalar o IronPDF usando o Console do Gerenciador de Pacotes NuGet com o seguinte comando:

Install-Package IronPdf

Instale o pacote IronPDF no Console do Gerenciador de Pacotes.

Com o projeto configurado e os pacotes necessários instalados, vamos definir a classe de conteúdo do PDF.

Definindo o conteúdo do PDF

Neste exemplo, um PDF de fatura simples será criado a partir dos códigos HTML em duas classes: InvoiceContent e 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

No código acima, uma classe abstrata PdfContent é definida com um método abstrato chamado RenderHtml. A classe InvoiceContent estende PdfContent e representa o conteúdo do PDF da fatura. Possui campos para o nome do cliente, endereço e uma lista de itens da fatura. A classe InvoiceItem contém duas propriedades: 'Descrição' e 'Preço'. O método RenderHtml gera a marcação HTML para a fatura com base no conteúdo.

Agora que o conteúdo do PDF está definido, vamos criar regras de validação usando o Fluent Validation.

Criando regras de validação

Para criar regras de validação para a classe InvoiceContent, crie uma classe validadora chamada InvoiceContentValidator. Esta classe herdará de AbstractValidator<InvoiceContent>, que é fornecida pelo 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

No código-fonte, a classe InvoiceContentValidator está definida, a qual herda de AbstractValidator<InvoiceContent>. Dentro do construtor da classe validadora, o método RuleFor define as regras de validação para cada propriedade da classe InvoiceContent.

Por exemplo, RuleFor(content => content.CustomerName) especifica que o nome do cliente não deve estar vazio. Da mesma forma, são definidas regras de validação para as propriedades de endereço e itens da fatura.

O método RuleForEach itera sobre cada item na lista InvoiceItems e aplica o InvoiceItemValidator. A classe InvoiceItemValidator contém regras de validação para a classe InvoiceItem.

Com essas regras de validação definidas, vamos prosseguir para a geração do PDF usando o IronPDF.

Gerando PDF usando o IronPDF

IronPDF - Gerar e Editar Documentos PDF é uma biblioteca .NET popular para criar e manipular documentos PDF. O IronPDF será utilizado para gerar o PDF com base no conteúdo da fatura validada.

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

A classe PdfService fornece um método GeneratePdf. Este método recebe um objeto PdfContent como entrada e gera o documento PDF com base no conteúdo validado.

Primeiro, ele recupera o validador apropriado para o conteúdo chamando o método GetValidatorForContent, que verifica o tipo de conteúdo e retorna o validador correspondente. Em nosso caso, damos suporte ao InvoiceContent e usamos o InvoiceContentValidator.

Em seguida, o conteúdo é validado usando o validador, chamando seu método Validate. O resultado da validação é armazenado em um objeto ValidationResult.

Se a validação falhar (!validationResult.IsValid), um FluentValidation.ValidationException é lançado com os erros de validação. Caso contrário, o PDF é gerado usando o IronPDF.

Uma instância de ChromePdfRenderer é criada para renderizar o conteúdo HTML como um PDF. O método RenderHtmlAsPdf é chamado no objeto renderer, passando o HTML gerado pelo método content.RenderHtml, gerando o documento PDF.

Agora que definimos a lógica de geração do PDF, vamos lidar com quaisquer erros de validação que possam ocorrer.

Tratamento de erros de validação

Quando ocorre um erro de validação, queremos exibir uma mensagem de erro e tratá-lo de forma adequada. Vamos modificar o método Main da classe Program para lidar com quaisquer exceções e exibir mensagens significativas para o usuário.

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

No código acima, os blocos try-catch são usados ​​para capturar quaisquer exceções que possam ocorrer. Se uma exceção for capturada, uma mensagem de erro será exibida ao usuário usando Console.WriteLine.

Agora vamos testar essa aplicação com diferentes cenários para validar a geração de PDFs e as regras de validação.

Testando o aplicativo

No exemplo de código, existem três cenários para testar:

1. Nome do cliente vazio: Deixe o campo do nome do cliente vazio para gerar um erro de validação.
2. Itens de fatura vazios: Forneça uma lista vazia de itens de fatura para acionar um erro de validação.
3. Geração bem-sucedida: Forneça conteúdo válido para gerar o PDF com sucesso.

Execute o aplicativo e observe a saída no console.

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!

O erro de saída no console

O arquivo PDF de saída

Como esperado, erros de validação são exibidos nos dois primeiros cenários e uma mensagem de sucesso no terceiro cenário.