> ## Content Index
> Fetch the complete content index at: https://www.azurebrasil.cloud/llms.txt
> Use this file to discover other available public pages before exploring further.

# A Importância da Validação com FluentValidation em Aplicações ASP.NET MVC
- URL: https://www.azurebrasil.cloud/blog/a-importancia-da-validacao-com-fluentvalidation-em-aplicacoes-asp-net-mvc/
- Published: 2025-05-05T12:00:00.000Z
- Updated: 2025-05-06T11:15:51.000Z
- Author: Felipe Faria
- Tags: #fluentvalidation, #aspnet, #aspnetmvc, #developer

Quando estamos desenvolvendo aplicações web, especialmente aquelas que lidam com o cadastro e manipulação de dados sensíveis, garantir a integridade e a consistência desses dados é essencial. Uma das formas mais elegantes e eficazes de realizar essa tarefa no ASP.NET é por meio da biblioteca **FluentValidation**.

Neste artigo, vou mostrar como utilizei o FluentValidation na minha aplicação ASP.NET MVC para validar o cadastro de clientes e quais benefícios essa abordagem trouxe para o projeto.

## Por que usar FluentValidation?

O FluentValidation é uma biblioteca popular no ecossistema .NET que permite definir regras de validação de forma fluente, limpa e separada da lógica do controlador ou modelo. Ele promove um código mais organizado, reutilizável e fácil de manter.

Ao invés de usar *DataAnnotations* diretamente no ViewModel, podemos centralizar as regras de negócio em uma classe separada, mantendo o princípio da **responsabilidade única (SRP)** e favorecendo a **injeção de dependência**, facilitando testes unitários e manutenções futuras.

## Como foi aplicado

Na minha aplicação de gerenciamento de clientes, implementei uma classe `AddClientValidator` para validar os dados enviados ao tentar adicionar um novo cliente ao sistema. Essa classe herda de `AbstractValidator<T>` e define regras claras para os campos do ViewModel.

### Exemplo de Validador

```C#
public class AddClientValidator : AbstractValidator<AddClientViewModel>
{
    public AddClientValidator(SystemContext context)
    {
        RuleFor(x => x.CRM).NotEmpty().WithMessage("CRM é obrigatório")
            .MaximumLength(20).WithMessage("O CRM deve ter no máximo {MaxLength} caracteres.")
            .Must(crm => !context.Client.Any(m => m.CRM == crm)).WithMessage("Este CRM já está em uso.");

        RuleFor(x => x.Name).NotEmpty().WithMessage("Nome é obrigatório")
            .MaximumLength(200).WithMessage("O Nome deve ter no máximo {MaxLength} caracteres.");
    }
}
```

### Registro do Validador no `Program.cs`

Para que o FluentValidation reconheça automaticamente os validadores, basta registrá-los no container de injeção de dependência:

```C#
builder.Services.AddScoped<IValidator<AddClientViewModel>, AddClientValidator>();
```

### Utilização no Controller

Dentro do `ClientController`, a validação é chamada explicitamente antes de salvar os dados:

```C#
public class ClientController : Controller
{
    // GET
    private readonly SystemContext _context;
    private readonly IValidator<AddClientViewModel> _addClientValidator;
.
.
.
  [HttpPost]
  [ValidateAntiForgeryToken]
  public IActionResult Add(AddClientViewModel dados)
  {
      var validation = _addClientValidator.Validate(dados);
  
      if (!validation.IsValid)
      {
          validation.AddToModelState(ModelState, string.Empty);
          return View(dados);
      }
  
      var client = new Client
      {
          CRM = dados.CRM,
          Name = dados.Name
      };
  
      _context.Client.Add(client);
      _context.SaveChanges();
  
      return RedirectToAction(nameof(Index));
  }
}
```

Essa abordagem separa claramente as responsabilidades:

- O ViewModel representa apenas os dados.
- O Validator define as regras.
- O Controller coordena a operação.

## Benefícios dessa abordagem

1. **Manutenção facilitada:** As regras de validação estão centralizadas em um único lugar.
2. **Reutilização:** O mesmo validador pode ser utilizado em diferentes partes da aplicação.
3. **Legibilidade:** A sintaxe fluente torna o código mais expressivo e fácil de entender.
4. **Testabilidade:** As regras podem ser testadas isoladamente com testes unitários.

## Conclusão

O FluentValidation é uma poderosa ferramenta para garantir que os dados que entram na sua aplicação sejam válidos, consistentes e seguros. Em sistemas mais complexos, essa validação se torna ainda mais essencial para evitar duplicações, inconsistências ou falhas críticas.

Utilizá-lo com ASP.NET MVC proporciona uma estrutura robusta, modular e pronta para escalar com segurança e qualidade.