Fluent Validation

Dependendo do tamanho do projeto, fazer as validações de objetos em C# pode ser estressante e cansativo. Sempre que criamos uma aplicação, temos modelos que podem ser validados. Essas validações além de complexas podem se tornar incompreensíveis se forem mal escrita.

Desse modo, o Fluent Validation é uma ferramenta disponível no mercado que simplifica a forma como fazemos nossas validações. Com ele podemos validar nossas propriedades e objetos de forma clara e de fácil compreensão, além de fáceis de se testar.

Existem várias vantagens em utilizar essa biblioteca, seus destaques são:

Separacão das Preocupações: A validação é separada da regra de negócio e da camada de dados.
Sintaxe Fluente: Sintaxe intuitiva e legível, permitindo que você escreva validações de forma clara e concisa.
Extensibilidade: Você pode estender a biblioteca para adicionar suas próprias regras de validação ou modificar o comportamento existente.
Mensagens de erros personalizadas
Integração com o ASP NET Core

Instalando pacote no Nuget

Para começar, é necessário instalar o pacote pela interface do Nuget ou pelo Package Manager Console

 install-package FluentValidation.AspNetCore

Abordagens

Existem várias formas de abordar esse tipo de validação. A escolha depende da necessidade do projeto.

Integração com o ASP NET Core

Essa abordagem registra os validadores durante a configuração da aplicação. O ASP NET Core uas esses validadores automaticamente para validar os modelos de entrada. Vamos para um exemplo completo:

1. Modelo

Primeiro, vamos definir um modelo simples chamado Cliente.

public class Cliente
{
    public string Nome { get; set; }
    public string Email { get; set; }
    public int Idade { get; set; }
}

2. Validador

O segundo arquivo será o nosso próprio validador.

Ele estende a classe AbstractValidator<T>, onde T é o tipo que você deseja validar.

Ao herdar o AbstractValidator<T>, o NovoClienteValidator herda todas as funcionalidades da classe base, permitindo definir regras de validação específicas para o modelo Cliente

using FluentValidation;

public class NovoClienteValidator : AbstractValidator<Cliente>
{
    public NovoClienteValidator()
    {
        RuleFor(cliente => cliente.Nome)
            .NotEmpty().WithMessage("O nome é obrigatório.")
            .Length(2, 50).WithMessage("O nome deve ter entre 2 e 50 caracteres.");

        RuleFor(cliente => cliente.Email)
            .NotEmpty().WithMessage("O email é obrigatório.")
            .EmailAddress().WithMessage("O email fornecido não é válido.");

        RuleFor(cliente => cliente.Idade)
            .InclusiveBetween(18, 100).WithMessage("A idade deve estar entre 18 e 100 anos.");
    }
}

3. Controller

Agora, vamos criar um controlador que usa o modelo Cliente e valida as solicitações de entrada.

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class ClientesController : ControllerBase
{
    [HttpPost]
    public IActionResult CriarCliente([FromBody] Cliente cliente)
    {
        // A validação será feita automaticamente pelo FluentValidation
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        // Lógica para adicionar o cliente no banco de dados (omita por simplicidade)
        return Ok("Cliente criado com sucesso!");
    }
}

4. Configuração de Startup

Existem duas maneiras de configurar o Fluent API. A primeira é uma configuração simples feita diretamente no arquivo de inicialização (Startup), que funciona bem para projetos menores. A segunda abordagem é mais robusta e é usada em projetos maiores e mais complexos, oferecendo mais flexibilidade.

A. No Arquivo Startup

using AL.Manager.Validator.Conta;
using AL.WebApi.Configuration;
using CL.WebApi.Configuration;
using FluentValidation.AspNetCore;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers()
    .AddFluentValidation(p =>
        {
            p.RegisterValidatorsFromAssemblyContaining<NovaContaValidator>();

            p.ValidatorOptions.LanguageManager.Culture = new System.Globalization.CultureInfo("pt-br");
        }); ;

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

builder.Services.AddDataBaseConfiguration(builder.Configuration);

builder.Services.AddDependencyInjectionConfiguration();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseDatabaseConfiguration();

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

B. Arquivo de Configuração

A segunda abordagem é criar em um arquivo de configuração. Na mesma raiz do projeto: Configuration/FluentValidationConfig

using  AL.Manager.Validator.Conta;
using FluentValidation.AspNetCore;

namespace CL.WebApi.Configuration;

public static class FluentValidationConfig
{
    public static void AddFluentValidationConfiguration(this IServiceCollection services)
    {
        services.AddControllers()
        .AddFluentValidation(p =>
        {
            p.RegisterValidatorsFromAssemblyContaining<NovaContaValidator>();

            p.ValidatorOptions.LanguageManager.Culture = new System.Globalization.CultureInfo("pt-br");
        });

    }
}

Agora é necessário chamar o nosso método criado anteriormente no startup do programa.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddFluentValidationConfiguration();

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

builder.Services.AddDataBaseConfiguration(builder.Configuration);

builder.Services.AddDependencyInjectionConfiguration();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseDatabaseConfiguration();

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();