No artigo anterior (o quarto desta série) vimos de forma superficial, como se dá o processo de acesso e manipulação de dados com ASP.NET MVC utilizando o Entity Framework 4. Vimos também como é possível construir views fortemente tipadas utilizando helpers como ferramentas de apoio. Muito embora conceitos importantes tenham sido apresentados neste artigo, um aspecto fundamental de sistemas em geral não foi levado em consideração: a validação das informações que entram no sistema. Note, qual o sentido em se construir uma aplicação que colete informações mas que não garanta em maior grau a veracidade destas?
No artigo de hoje veremos uma forma para validação dos dados – “Data Annotations“. Entenda-se aqui como “validação de dados” a validação de informações fornecidas pelo usuário em um formulário qualquer de página web construído sob o padrão MVC. Para a construção dos exemplos deste artigo, utilizaremos a mesma aplicação mencionada nos outros artigos da série, especialmente os exemplos apresentados no artigo anterior a este.
Validando dados com Data Annotations
Data Annotations é um recurso disponível na framework de forma nativa a partir da versão 2. Muito embora seja nativa a partir da versão 2 do ASP.NET MVC, é possível trabalhar com Data Annotations em versões anteriores, bastando para isso, efetuar o download e a instalação do Data Annotations Model Binder. Se este é seu caso, baixe o pacote no Codeplex clicando aqui.
Mas você deve estar se perguntando: O que faz este Data Annotations? Basicamente, esta técnica consiste na decoração de propriedades de uma classe com alguns atributos específicos, sendo que estes podem ser parametrizados. Assim, na execução do postback, ao controller invocar a action específica para a operação, os valores para associados a cada propriedade são confrontados (de acordo com os parâmetros informados para os atributos). Caso satisfaçam os parâmetros, libera o envio, caso contrário, não libera.
Para demonstrar este conceito, iremos utilizar o “cadastro de novos usuários”, apresentado no artigo 4 desta série. Assim, com o Visual Studio aberto, vá até a Solution Explorer do projeto e dê um duplo clique sobre o arquivo “Create.aspx” localizado em “~/Views/Usuarios/“. Executando este arquivo, será fácil notar que o formulário de cadastro de novos usuários aceita o cadastro de campos em branco, e-mails inválidos, etc. Portanto, o que faremos é realizar a validação destas informações antes do envio ao banco de dados via Data Annotations.
Na pasta “Models” de seu projeto, clique com o botão direito do mouse e selecione a opção “Add class…“. Neste arquivo, substitua o código gerado pelo código apresentado pela Listagem 1.
[csharp]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.ComponentModel.DataAnnotations;
using System.Web.Mvc;
namespace SitePessoalMVC.Models
{
[MetadataType(typeof(UsuariosMetadata))]
public partial class tbUsuarios
{
}
[Bind(Exclude=”IDUsuario”)]
public class UsuariosMetadata
{
[Required(ErrorMessage=”Por favor, informe seu nome.”)]
public string NomeCompleto { get; set; }
[Required(ErrorMessage=”Por favor, informe o username.”)]
public string Username { get; set; }
[Required(ErrorMessage=”Por favor, informe a senha”)]
public string Password { get; set; }
}
}
[/csharp]
Listagem 1: Validando propriedades via Data Annotations
Linha a linha, entendamos o que faz o código apresentado pela Listagem 1.
- Linhas 5 e 6: Na linha 5 adicionamos a referência a classe Data Annotations. Como mencionado anteriormente, o namespace “ComponentModel” que traz a classe “Data Annotations” já é nativo na framework a partir da versão 2. Esta classe encapsula todos os atributos e demais recursos para efetuar a validação de modelo. Na linha 6 trazemos ao contexto da classe o namespace MVC.
- Linha 10: Decoramos a classe “tbUsuarios” com o atributo “[MetadataType(typeof(UsuariosMetadata))]“. Basicamente o que estamos fazendo aqui é informar a framework que as alterações escritas para “tbUsuarios” devem ser revertidas para o que está sendo implementado pela classe “UsuariosMetadata”.
- Linha 11: Aqui criamos a classe parcial “tbUsuarios”. Não entraremos em maiores detalhes aqui sobre classes parciais, pois este não é o foco deste artigo, mas, basicamente, precisamos que “tbUsuarios” seja parcial porque estamos adicionando novos comportamentos a classe “tbUsuarios” gerada pelo EF4, sem necessariamente precisarmos alterar o conteúdo da classe original.
- Linha 15: “Dizemos” através do atributo “Bind” que ao efetuar o “binding” das informações, a própriedade “IDUsuario” deve ser desconsiderada. Isso porque “IDUsuario” é do tipo autoincrement e, por consequência, não precisamos “bindar” seu valor.
- Linha 16: Criamos a classe “UsuariosMetadata”.
- Linhas 19, 22 e 25: Criamos as propriedades da classe. A observação importante aqui é, como estamos trabalhando no contexto do modelo de dados e estamos escrevendo uma classe partial, baseada naquela gerada pelo EF4, os tipos e nomes das propriedades devem ser os mesmos.
- Linhas 18, 21 e 24: Adicionamos os atributos “Required” a cada uma das propriedades onde queremos que os valores sejam obrigatórios.
O passo seguinte, consiste em validarmos o modelo no momento do postback. Para isso, abra o controller “UsuariosController” e localize a action “Create” decorada com o atributo HttpPost. Substitua o conteúdo da action por aquele apresentado na Listagem 2.
[csharp]
[HttpPost]
public ActionResult Create(tbUsuarios objUsuario)
{
TryUpdateModel(modelo);
if (ModelState.IsValid)
{
modelo.AddTotbUsuarios(objUsuario);
modelo.SaveChanges();
return RedirectToAction(“Index”);
}
else
{
return View();
}
}
[/csharp]
Listagem 2: Validando o modelo de dados no postback
O que fazemos acima, conforme mencionado anteriormente, consiste na validação do modelo de dados antes do envio das informações. Assim, é importante observar primeiro a linha 4, onde encontramos “TryUpdateModel(modelo)“. Aqui, como o próprio nome do método sugere, estamos “tentando” validar o modelo de dados. Em seguida, verificamos através de um if se o modelo é valido e, em caso afirmativo, enviamos os dados, como pode ser visto nas linhas 6, 8, 9 e 10.
Ao finalizar este processo e executar sua aplicação, se tudo correu bem, você deverá estar visualizando a tela semelhante a Figura 1.
Figura 1: Formulário sendo validado
Você deve estar se perguntando: mas como a view sabe onde exibir os erros? A resposta está na própria view. Abra o arquivo “Create.aspx“. A Listagem 2 apresenta o código da view.
[html]
<%@ Page Title=”” Language=”C#” MasterPageFile=”~/Views/Shared/Site.Master” Inherits=”System.Web.Mvc.ViewPage<SitePessoalMVC.Models.tbUsuarios>” %>
<asp:Content ID=”Content1″ ContentPlaceHolderID=”TitleContent” runat=”server”>
Create
</asp:Content>
<asp:Content ID=”Content2″ ContentPlaceHolderID=”MainContent” runat=”server”>
<h2>Create</h2>
<% using (Html.BeginForm()) {%>
<%: Html.ValidationSummary(true) %>
<fieldset>
<legend>Fields</legend>
<div class=”editor-label”>
<%: Html.LabelFor(model => model.NomeCompleto) %>
</div>
<div class=”editor-field”>
<%: Html.TextBoxFor(model => model.NomeCompleto) %>
<%: Html.ValidationMessageFor(model => model.NomeCompleto) %>
</div>
<div class=”editor-label”>
<%: Html.LabelFor(model => model.Username) %>
</div>
<div class=”editor-field”>
<%: Html.TextBoxFor(model => model.Username) %>
<%: Html.ValidationMessageFor(model => model.Username) %>
</div>
<div class=”editor-label”>
<%: Html.LabelFor(model => model.Password) %>
</div>
<div class=”editor-field”>
<%: Html.TextBoxFor(model => model.Password) %>
<%: Html.ValidationMessageFor(model => model.Password) %>
</div>
<p>
<input type=”submit” value=”Create” />
</p>
</fieldset>
<% } %>
<div>
<%: Html.ActionLink(“Back to List”, “Index”) %>
</div>
</asp:Content>
[/html]
Listagem 2: View do formulário de cadastro
O segredo está nas linhas 22, 30 e 38.Como é possível notar, os dados são exibidos através do helper “Html” através do método “ValidationMessageFor( model => model.Propriedade )”. O helper está ligado diretamente ao modelo. Como estamos manipulando diretamente as propriedades da classe mãe (do modelo), ao os decorarmos com os atributos de Data Annotations as mudanças são refletidas no método “ValidationMessageFor” através da expressão lambda.
Por hoje era isso pessoal. Por favor, ao finalizar a leitura deste artigo, deixe seu comentário. Não demora 1 minuto e é de fundamental importância para que possamos melhorar a qualidade dos textos. No próximo artigo aprenderemos a trabalhar com rotas personalizadas. Não percam! Até lá! 🙂
Pingback: ASP.NET MVC – Início, Meio e Fim – Parte 5 | .NET Interior