C# Academy · Aula

Validação com anotações de dados

Valide modelos com atributos.

Validação com anotações de dados é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 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.

O que é a validação por anotações de dados?

Anotações de dados são atributos que você coloca nas propriedades do modelo para declarar regras de validação diretamente nas suas classes C#. O ASP.NET Core lê esses atributos durante a vinculação do modelo e valida automaticamente as solicitações recebidas.

Elas ficam no namespace System.ComponentModel.DataAnnotations.

using System.ComponentModel.DataAnnotations;

public class RegisterRequest
{
    [Required]
    public string Username { get; set; }
}

O atributo [Required]

[Required] garante que uma propriedade não seja nula (nem uma cadeia de caracteres vazia, por padrão). Se o cliente omitir o campo, a validação do modelo falhará antes da execução da sua ação.

Você pode personalizar a mensagem com ErrorMessage.

public class RegisterRequest
{
    [Required(ErrorMessage = "Username is required.")]
    public string Username { get; set; }

    [Required]
    public string Password { get; set; }
}

Validando números com [Range]

[Range] restringe um valor numérico a um mínimo e máximo inclusivos. Funciona com int, números de dupla precisão, decimal e outros tipos.

Use-o para idades, quantidades, classificações e qualquer número limitado por um intervalo.

public class ProductRequest
{
    [Range(1, 1000, ErrorMessage = "Quantity must be between 1 and 1000.")]
    public int Quantity { get; set; }

    [Range(0.01, 9999.99)]
    public decimal Price { get; set; }
}

Validando e-mails com [EmailAddress]

[EmailAddress] verifica se uma cadeia de caracteres se parece com um endereço de e-mail válido. Combine-o com [Required] para que o campo esteja presente e tenha o formato correto.

public class ContactRequest
{
    [Required]
    [EmailAddress(ErrorMessage = "Please enter a valid email.")]
    public string Email { get; set; }
}

Restrições de comprimento de cadeias de caracteres

[StringLength] define um comprimento máximo (e, opcionalmente, mínimo) para o texto. [MinLength] e [MaxLength] são alternativas mais simples.

public class RegisterRequest
{
    [Required]
    [StringLength(20, MinimumLength = 3)]
    public string Username { get; set; }

    [MaxLength(500)]
    public string Bio { get; set; }
}

Correspondência de padrões com [RegularExpression]

[RegularExpression] valida uma cadeia de caracteres com base em um padrão de expressão regular. É ideal para formatos como números de telefone, códigos postais ou identificadores de URL.

public class ProfileRequest
{
    [RegularExpression(@"^[a-z0-9-]+$",
        ErrorMessage = "Slug may only contain lowercase letters, digits and dashes.")]
    public string Slug { get; set; }
}

Comparando dois campos com [Compare]

[Compare] garante que uma propriedade corresponda a outra. O caso clássico é confirmar uma senha.

public class RegisterRequest
{
    [Required]
    public string Password { get; set; }

    [Compare(nameof(Password), ErrorMessage = "Passwords do not match.")]
    public string ConfirmPassword { get; set; }
}

Como ModelState informa os erros

Quando a validação falha, o ASP.NET Core preenche ModelState com os erros. Em um controlador de API decorado com [ApiController], as solicitações inválidas retornam automaticamente uma resposta 400, portanto raramente é necessário verificá-lo manualmente.

[ApiController]
[Route("api/[controller]")]
public class AccountController : ControllerBase
{
    [HttpPost("register")]
    public IActionResult Register(RegisterRequest request)
    {
        // [ApiController] already returned 400 if invalid
        return Ok("Registered " + request.Username);
    }
}

Verificações manuais de ModelState

Sem [ApiController] (por exemplo, em controladores MVC), você verifica ModelState.IsValid por conta própria e decide como responder.

public IActionResult Register(RegisterRequest request)
{
    if (!ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }
    return Ok();
}

Combinando várias anotações

As anotações se acumulam. Uma única propriedade pode conter vários atributos, e todos eles devem ser aprovados. A ordem não importa para a avaliação, mas mantenha-os organizados para facilitar a leitura.

public class SignupRequest
{
    [Required]
    [EmailAddress]
    [StringLength(254)]
    public string Email { get; set; }

    [Required]
    [Range(18, 120, ErrorMessage = "Must be 18 or older.")]
    public int Age { get; set; }
}

Quando as anotações de dados não são suficientes

As anotações de dados são ótimas para regras simples e declarativas. Porém, lógica entre propriedades, consultas ao banco de dados ou regras condicionais ("obrigatório somente quando X") rapidamente se tornam difíceis de manejar. É nesse ponto que o FluentValidation se destaca, assunto que abordaremos a seguir.

Verificação rápida

Teste sua compreensão sobre anotações de dados.

Recapitulação

Você aprendeu que as anotações de dados declaram regras de validação como atributos: [Required] para indicar presença, [Range] para limites numéricos, [EmailAddress] para o formato de e-mail, além de [StringLength], [RegularExpression] e [Compare]. Com [ApiController], as falhas retornam automaticamente o status 400 por meio de ModelState. Para regras complexas, use o FluentValidation a seguir.

Perguntas Frequentes

A aula “Validação com anotações de dados” é grátis?

Sim — o texto completo de “Validação com anotações de dados” é 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 “Validação com anotações de dados”?

Valide modelos com atributos. 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 1 de 4.

Quanto tempo leva a aula “Validação com anotações de dados”?

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