C# Academy · Aula

Regras do FluentValidation

Escreva validadores expressivos com sintaxe fluente.

Regras do FluentValidation é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Por que usar FluentValidation?

FluentValidation é uma biblioteca popular do .NET que move as regras de validação dos modelos para classes de validator dedicadas. As regras são expressas com uma API legível, encadeável e fluente, mantendo os modelos limpos e as regras fáceis de testar.

dotnet add package FluentValidation
dotnet add package FluentValidation.DependencyInjectionExtensions

A classe base AbstractValidator

Você escreve um validator herdando de AbstractValidator<T>, em que T é o modelo que será validado. As regras são definidas no construtor.

using FluentValidation;

public class CustomerValidator : AbstractValidator<Customer>
{
    public CustomerValidator()
    {
        // rules go here
    }
}

Definindo sua primeira regra com RuleFor

RuleFor seleciona uma propriedade por meio de uma expressão lambda; depois, você encadeia validadores nela. NotEmpty() rejeita valores nulos, cadeias de caracteres vazias e valores padrão.

public class CustomerValidator : AbstractValidator<Customer>
{
    public CustomerValidator()
    {
        RuleFor(c => c.Name).NotEmpty();
    }
}

Encadeando vários validadores

Cada RuleFor pode encadear vários validadores. Eles são executados na ordem, e todos devem ser aprovados. A leitura é quase como a de uma frase.

RuleFor(c => c.Name)
    .NotEmpty()
    .MinimumLength(2)
    .MaximumLength(50);

Validadores integrados

O FluentValidation inclui muitos validadores: NotNull, NotEmpty, EmailAddress, Length, InclusiveBetween, GreaterThan, Matches (expressão regular) e outros.

RuleFor(c => c.Email).NotEmpty().EmailAddress();
RuleFor(c => c.Age).InclusiveBetween(18, 120);
RuleFor(c => c.Phone).Matches(@"^\+?[0-9]{7,15}$");

Mensagens de erro personalizadas

Use WithMessage para substituir a mensagem padrão. Você pode interpolar marcadores como {PropertyName} e {PropertyValue}.

RuleFor(c => c.Email)
    .NotEmpty().WithMessage("Email is required.")
    .EmailAddress().WithMessage("{PropertyValue} is not a valid email.");

Códigos de erro e gravidade personalizados

Além das mensagens, você pode associar um WithErrorCode legível por máquinas e um WithSeverity (Erro, Aviso, Informação) para ajudar os clientes a reagirem de maneiras diferentes.

RuleFor(c => c.Name)
    .NotEmpty()
    .WithErrorCode("NAME_REQUIRED")
    .WithSeverity(Severity.Error);

Validando objetos aninhados

Use SetValidator para reutilizar um validator em um objeto filho, mantendo as regras modulares.

public class OrderValidator : AbstractValidator<Order>
{
    public OrderValidator()
    {
        RuleFor(o => o.Customer).SetValidator(new CustomerValidator());
    }
}

Validando coleções

RuleForEach aplica regras a cada item de uma coleção.

public class OrderValidator : AbstractValidator<Order>
{
    public OrderValidator()
    {
        RuleForEach(o => o.Items)
            .ChildRules(item => item.RuleFor(i => i.Quantity).GreaterThan(0));
    }
}

Executando um validador manualmente

Você pode chamar um validator diretamente e inspecionar o resultado. ValidationResult expõe IsValid e uma lista de Errors.

var validator = new CustomerValidator();
ValidationResult result = validator.Validate(customer);

if (!result.IsValid)
{
    foreach (var error in result.Errors)
    {
        Console.WriteLine(error.PropertyName + ": " + error.ErrorMessage);
    }
}

Validação assíncrona

Quando uma regra precisa de E/S (como uma verificação no banco de dados), use ValidateAsync e validadores async, como MustAsync, que exploraremos na lição sobre regras personalizadas.

ValidationResult result = await validator.ValidateAsync(customer);

Verificação rápida

Teste os fundamentos do FluentValidation.

Recapitulação

O FluentValidation coloca as regras em classes AbstractValidator<T>. RuleFor tem como alvo uma propriedade; depois, você encadeia validadores integrados, como NotEmpty, EmailAddress e InclusiveBetween. Personalize o retorno com WithMessage, WithErrorCode e WithSeverity, reutilize a lógica com SetValidator e RuleForEach e execute as regras por meio de Validate/ValidateAsync.

Perguntas Frequentes

A aula “Regras do FluentValidation” é grátis?

Sim — o texto completo de “Regras do FluentValidation” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Regras do FluentValidation”?

Escreva validadores expressivos com sintaxe fluente. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Regras do FluentValidation”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy