Validações com FluenValidation

Marcos Lima — Tue, 13 Aug 2024 11:14:30 +0000

No desenvolvimento de software, validar os objetos de entrada é essencial para garantir a integridade dos dados e detectar problemas desde as fases iniciais. Nesse cenário, o FluentValidator se destaca como uma biblioteca amplamente utilizada para realizar a validação de modelos de forma eficiente e estruturada.

Neste exemplo, construiremos uma API em .NET 8 com a responsabilidade de cadastrar pessoas. Para isso, começaremos definindo um modelo Person com alguns campos:

public record Person 
{
    public string Name { get; set; } = string.Empty!;
    public string Document{ get; set; } = string.Empty!;
    public string Email { get; set; } = string.Empty!;
    public int Age { get; set; }
}

Com o modelo definido, é hora de adicionar o pacote FluentValidation ao projeto. Para isso, execute o comando abaixo em seu projeto:

dotnet add package FluentValidation.AspNetCore

Agora podemos começar a implementar as validações. Para isso, crie uma pasta chamada Validators e, dentro dela, adicione a classe PersonValidators:

public class PersonValidator : AbstractValidator<Person> 
{
  public PersonValidator() 
  {
        RuleFor(x => x.Name).Length(0, 100)
            .WithMessage("O Nome é obrigatório");
        RuleFor(x => x.Email).EmailAddress()
            .WithMessage("Endereço de e-mail inválido");
        RuleFor(x => x.Age).InclusiveBetween(18, 60)
            .WithMessage("Deve ter entre 18 e 60 anos");
        RuleFor(x => x.Document).Length(11)
            .WithMessage("CPF inválido, deve ter 11 digitos.");
  }
}

Após implementar a classe com as regras de validação, é necessário registrar o validador no ServiceProvider. Em seguida, resolva sua dependência para que o .NET possa reconhecer e executar as validações. Existem duas maneiras de registrar validadores ao ServiceProvider. A primeira é registrá-los individualmente na classe Program:

builder.Services.AddScoped<IValidator<Person>, PersonValidator>();

No entanto, se o seu projeto tiver muitos validadores, utilizar essa abordagem se torna inviável e aumenta as chances de erros. Logo, podemos utilizar a abordagem de registrar todos os validadores de uma só vez no mesmo assembly PersonValidator.

builder.Services.AddValidatorsFromAssemblyContaining<PersonValidator>();

Com os validadores registrados, vamos implementar o trecho de código que realiza as validações e identifica possíveis erros. Veja abaixo como ficou a implementação:

public class PersonController : ControllerBase
{
    private IValidator<Person> _validator;

    public PersonController(IValidator<Person> validator) =>
        _validator = validator;

    [HttpPost(Name = "PostPerson")]
    public IActionResult Post(Person person)
    {
        var validationResult = _validator.Validate(person);

        if(validationResult.IsValid is false) 
        {
            var errors = validationResult.Errors.Select(_ => _.ErrorMessage);
            return BadRequest(errors);
        }

        return Ok();
    }
}

Observe que o código responsável por validar o objeto de entrada está localizado dentro do método do controller. Optamos por essa abordagem para manter a implementação simples, sem isolar essa responsabilidade em um serviço separado. No entanto, uma melhoria seria permitir que o próprio modelo Person se validasse. Isso permitiria centralizar as regras de negócio no próprio modelo. Para isso, adicione o método Validate na classe Person:

public (bool isValid, IEnumerable<string> Errors) Validate(IValidator<Person> validator) 
{
    var validationResult = validator.Validate(this);
    return (validationResult.IsValid, validationResult.Errors.Select(_ => _.ErrorMessage));
}

Observe que o método retorna uma tupla indicando se o objeto é válido, caso seja inválido, ele também retorna uma lista com os erros. Agora vamos ajustar o controller para utilizar esse método:

public class PersonController : ControllerBase
{
    private IValidator<Person> _validator;

    public PersonController(IValidator<Person> validator) =>
        _validator = validator;

    [HttpPost(Name = "PostPerson")]
    public IActionResult Post(Person person)
    {
        var validationResult =  person.Validate(_validator);

        if(validationResult.isValid is false)
            return BadRequest(validationResult.Errors);

        return Ok();
    }
}

Dessa forma isolamos as regras de validações dentro do modelo de entrada e eliminamos essa responsabilidade do controller.
Com isso cumprimos o objetivo do artigo que era trazer uma visão geral dessa biblioteca de forma prática para resolver problemas de validações de modelos.

No próximo artigo iremos implementar essas verificações através de Filters. Pois, sempre que uma requisição for solicitada à API, o Filter será acionado e fará a validação dos objetos de entrada. Nessa etapa a aplicação decide se deve prosseguir ou retornar os erros para o cliente.

Código fonte disponível no Github/Llimaa: DemoFluentValidation.

CancellationToken em aplicações .NET

Marcos Lima — Wed, 28 Feb 2024 01:24:20 +0000

O objetivo desse artigo é demonstrar como utilizar o cancellationToken em aplicações .NET através de um exemplo simples e prático.

Mas, a final o que é o CancellationToken? bem, o cancellationToken no C sharp é uma struct, responsável por propagar uma notificação informando que as operações assíncronas devem ser canceladas, ou seja, devem encerrar seus processos e liberar os recursos que estão consumindo na execução de sua tarefa.

Caso de uso
Imagine o seguinte cenário: Você tem uma API que retorna uma lista de itens X para serem renderizados em um sistema, mas a API demora alguns segundos para retornar os dados, pois ela faz algumas consultas no banco de dados e algumas validações. Agora, imagine o usuário utilizando o sistema que consome os dados da sua API e note que está demorando certo tempo para exibir as informações, então o usuário decide recarregar a página algumas vezes, mas e aí? O que vai acontecer com as solicitações que o usuário fez a cada vez que recarregou a página? Bem, é aí que entra a importância de utilizar o cancellationToken.

Imagine que nesse cenário acima não estamos utilizando o cancellationToken, logo, a cada vez que o usuário recarregar a página vai sobrecarregar mais o sistema e consumir mais recursos sem necessidade, pois a aplicação vai tentar processar todas as solicitações, mesmo que o usuário tente cancelar e pedir uma nova (no caso recarregando a página).
Agora fazendo uso do cancellationToken, a cada vez que o usuário recarregar a página vai ser lançado uma TaskCanceledException, e, assim, a operação vai ser encerrada. Com isso, não vamos sobrecarregar o servidor com requisições desnecessárias e liberar os recursos que estavam em uso.

Para um melhor entendimento, vamos ver um exemplo prático. Para isso, desenvolvi uma minimal API em .NET 7 que contém dois endPoints, nos quais um vai conter uma operação com o cancellationToken e o outro sem o cancellationToken.
Para deixar nosso exemplo simples, adicionamos um task.Delay para simular a demora que poderia ser uma integração com algum serviço externo ou uma query que busca informações na base de dados. Também adicionamos alguns logs durante a execução para ficar mais fácil o entendimento.

Segue o vídeo abaixo demostrando o projeto em execução:
https://youtu.be/gb-E1_8Q3e4?si=m54L3ohbSxAh6sHe

Note que, quando fazemos o request sem o cancellationToken, ao recarregar a página a execução continua até o fim, e quando utilizamos o cancellationToken, ao recarregar a página a execução é finalizada e os recursos são liberados.

Chegamos ao fim de mais um artigo, espero que tenha ficado claro a importância de utilizar o CancellationToken em suas aplicações web.

Abraços e até breve!

DEV Community: Marcos Lima

Validações com FluenValidation

CancellationToken em aplicações .NET