Caro(a) Leitor(a) hoje eu vou falar um pouco mais sobre essa tecnologia. Já ouvi muitos desenvolvedores falando que não gostou da forma de desenvolvimento, achou mais difícil de entender e que prefere fazer do jeito tradicional.
Hoje eu vou dar a minha opinião sobre o assunto e vou continuar o exemplo feito nos artigos anteriores.
Ferramentas utilizadas:
Visual Studio 2012
Linguagem: C#
Plataforma Web MVC
Comunicação com o banco de dados: “Entity” Framework Microsoft.
O padrão MVC da Microsoft é um pouco diferente dos outros padrões, principalmente porque os componentes utilizando “Razor” mudaram um pouco. Antes de começar a fazer um projeto do tipo MVC, o primeiro passo é pensar sempre em MVC.
A forma normal de desenvolvimento usando ASPX mudou. Mas mudou para melhor focando em produtividade, facilidade e padrão.
O primeiro padrão é o que conecta com o banco de dados. A Microsoft criou o “Entity Framework” responsável por conectar ao banco de dados e inserir, deletar, atualizar e selecionar valores.
Esse “framework” ajuda muito ao desenvolvedor gastando menos tempo com “pool”, “timeout”, “select”, “insert”, “delete”, “update” e outros tipos de comandos.
A minha opinião é que nem tudo da pra fazer usando MVC. Na verdade, nem tudo tem que ser feito usando MVC. Existem muitas maneiras de fazer um sistema ou um site, você só precisa definir o que vai fazer.
Continuando com o Projeto
No artigo parte 2, criamos a parte de cadastrar o site. A própria ferramenta cria os links para editar, detalhar e deletar. Neste artigo, vou mostrar como executar o link.
A listagem 1 mostra o link na página índex.cshtml.
Listagem 1 – Link Editar
@Html.ActionLink("Edit", "Edit", new { id=item.CHSite })
O link de edição chama um método “Edit” e passa parâmetro do tipo “id”, ou seja, a chave da tabela. Esse método precisa estar dentro da Controller, nesse caso do SiteController.cs. Listagem 2.
Listagem 2 – Criando método de edição de dados
// GET: /Site/Edit/5
public ActionResult Edit(int id)
{
var site = db.Sites.Find(id);
_return View(site);
}
Note que coloquei no método a entrada de “int”. Dentro do método utilizei a variável de contexto (que faz a comunicação com o banco de dados) com o objetivo de encontrar o item desejado de acordo com o “id”.
O código “db.Sites.Find(id)” busca os dados no banco de dados e armazena na variável “site” criada. Depois é necessário retornar o valor com os dados da variável, “View(site)”.
O método é simples no modo geral, mas é necessário criar o arquivo para visualização. Pra isso, clique com o botão direito em cima do nome “Edit” e escolha a opção “Add View”. Imagem 1.
Imagem 1 – Adicionando View de Edit.
Outra tela aparece com o objetivo de criar a “View” de edição dos dados. Seria no caso apenas o formulário baseado na classe “SiteController”. Imagem 2.
Imagem 2 – Criando formulário de edição.
Note que o nome da “View” é “Edit”; o mesmo nome do método. A “engine” é o “Razor”. Depois disso, marquei a opção “Create a strongly-type view”, automaticamente apareceu todas as classes models.
Escolhi a “model” “Site (... Models)” que faz referência direta a classe. Depois escolhi a opção “Edit” no “Scaffold template”. Isso quer dizer que é usado um “template” de edição para aquele formulário. Depois disso clique no botão “Add”.
O Visual Studio 2012 criou um arquivo chamado “Edit.cshtml” dentro da pasta “View >> Site”. Essa “View” criada possui partes em HTML e partes em .NET. Listagem 3.
Listagem 3 – Página Edit.cshtml.
@model
MVCSAC.Models._Site
@{
ViewBag.Title = "Edit";
}
<h2>Edith2>
@using (Html.BeginForm()) {
@Html.ValidationSummary(true)
<fieldset>
<legend>Sitelegend>
@Html.HiddenFor(model =>
model.CHSite)
<div class="editor-label">
@Html.LabelFor(model =>
model.NOSite)
div>
<div class="editor-field">
@Html.EditorFor(model =>
model.NOSite)
@Html.ValidationMessageFor(model
=> model.NOSite)
div>
<div class="editor-label">
@Html.LabelFor(model =>
model.SITSite)
div>
<div class="editor-field">
@Html.EditorFor(model =>
model.SITSite)
@Html.ValidationMessageFor(model
=> model.SITSite)
div>
<p>
<input type="submit" value="Save" />
p>
fieldset>
}
<div>
@Html.ActionLink("Back to List", "Index")
div>
@section Scripts {
@Scripts.Render("~/bundles/jqueryval")
_}_
Esse formulário é muito simples. Ainda falta programar a parte que pega os dados digitados pelo usuário. Depois de digitar os dados e clicar no botão “Save”, os dados precisam ser pegos e gravados dentro da tabela do banco de dados.
Pra isso, é necessário criar outro método dentro da classe “SiteController.cs”. Listagem 4.
[HttpPost]
public ActionResult Edit(Site site)
{
db.Entry(site).State = System.Data.EntityState.Modified;
db.SaveChanges();
return RedirectToAction("Index");
_}
No topo do método foi colocado o comando [HttpPost]. Isso quer dizer que os dados virão pelo clique do botão e “post” do formulário. A entrada do método é a classe Site (com get e set).
A primeira linha dentro do método eu chamo a variável de contexto, mudo o estado dele para modificado e mando salvar as mudanças. O “Entity Framework” detecta os dados que precisam ser alterados, busca pela chave e faz o “update” na tabela automaticamente.
Essa é mais uma prova de que o “framework” ajuda muito ao usuário. Com duas linhas de código os dados foram alterados sem qualquer problema.
No final do método o usuário é redirecionado para a classe “Index” criada no artigo parte 2. Imagem 3.
Imagem 3 – Editando os dados pelo formulário.
Note que a URL ficou /Site/Edit/2. Esse Edit chama automaticamente a classe Edit criada e o Edit.cshtml. Mudei para “I” a situação e cliquei em Save.
O formulário chamou o método HTTPPost, alterou os dados no banco de redirecionou para a classe “Index” que mostra todos os dados. Imagem 4.
Imagem 4 – Dados alterados.
Note que o dado foi alterado sem qualquer problema. Nos próximos artigos, vamos fazer a classe de “Delete”. Qualquer dúvida pode entrar em contato pelo site pessoal
www.mauriciojunior.org.
