Há certo tempo recebi dois e-mails sobre com alguns questionamentos sobre MVC, que hoje em dia tem sido muito falado por todos (principalmente pelo programadores de .NET). O objetivo deste post é tentar esclarecer o que é o Design Patterns (Padrões de Projeto) MVC.

Bom, MVC significa Model, View e Controller. A ideia básica do MVC é de separar a lógica de negócio da apresentação (muito semelhante ao modelo de 3 Camadas. Bom, posso estar enganado e se estiver por favor comentem pois este é o objetivo). Vamos entender o que significa própriamente cada uma da letras.

M (Model)

Esta “camada” representa os dados da aplicação e as regras de negócio do acesso e modificação desses dados. Ela é quem fornece ao controlador a capacidade de acessar as funcionalidades da aplicação(Insert, Update, Delete).

Ultimamente tenho lido alguns forúns (alguns bem antigos por sinal) e percebi uma certa discussão sobre o que deve ficar no Model. Alguns dizem que a regra de negócio deve ficar no Model, mas eu particularmente acho bem mais interessante deixar o Model como sendo a DAL. Uma “camada” onde são tratadas as ações de Insert, Update, Delete e Select.

V (View)

As Views servem apenas para exibir as informações. São elas que renderizam o conteúdo de uma parte particular do modelo e encaminha para o controlador as ações do usuário. A View também acessa os dados do modelo através do controlador (Controller) e determina como esses dados devem ser apresentados.

Bom, comparando ainda com o modelo 3-tier (3 Camadas) essa seria a Interface.

C (Controller)

O controller define o comportamento da aplicação, é ele que interpreta as ações do usuário (View) e as mapeia para chamadas do modelo (Model).

Aqui sim ficaria a regra de negócio do nosso projeto. Grande partes dos post que li, tem colocado o controller como uma “gatilho” que serve apenas para disparar e identificar quais ações devem ser executadas no Model, mas para mim o Controller seria nossa BLL do modelo 3-tier.

Bom, é claro que esse é meu ponto de visto sobre como se pode utilizar este modelo.

Aqui estou apresentando uma imagem baseada em um modelo que realmente não me lembro onde vi. Ela mostra como são realizadas as requisições:

1 - O usuário realiza uma requisição de uma View (página web) ao Controller. Ex: Preenchimento do formulário de cadastro.

2 - O Controller recupera todas as informações da View e solicita uma ação (Insert por exemplo) para o Model. O Model processa a ação (grava em banco de dados) e devolve o resultado deste processamento para o Controller.

3 - O Controller processa o resultado e devolve para View o que ela deve exibir.

4 - A View recebe o que foi processado pelo Controller e exibe o resultado para o usuário. (Enteda a View como a página exibida) Ex: Imaginando um cadastro que foi realizado com sucesso, o retorno pode ser uma Mensagem de Sucesso.

Em resumo o modelo MVC é muito usado em aplicações para  Web, onde a View é a página  HTML, o controller é quem gera os dados dinâmicos para dentro da View (HTML) e o Model é representado pelo manutenção dos dados, ou seja, armazenagem em BD ou outros tipos de arquivos.

Bom, espero que com este post eu possa ter esclarecido um pouco como funciona esse Design Pattern. A idéia é simples mas pode confundir um pouco, mas nada uma boa leitura não ajude.

Em breve tem mais.

Agora é oficial, saiu a versão final do ASP.NET MVC. Com pouco mais de 20 dias de atraso (estava sendo previsto o lançamento para o final de fevereiro) saiu a versão final do ASP.NET MVC e agora a MSDN possui a documentação. (veja a documentação aqui).

Você pode acompanhar tutorias liberados para Microsoft aqui ou também pode ver alguns exemplos que criei aqui no blog nas categorias MVC, Linq ou JQuery que é a biblioteca javascript oficial do MVC.

Pegue a versão do MVC 1.0 e aproveite este lançamento, que eu particularmente estou gostando.

Espero que vocês tenham gostado desta dica.

No novo MVC você tem a capacidade de criar seus elementos HTML personalizados atráves da classe HTMLHelper.
O objetivo é que você possa criar uma estrutura na qual diminua a quantidade de HTML padrão que você irá escrever.
Vamos ver o exemplo abaixo:

Imagine que você queira criar um HTMLHelper que crie este HTML padrão.

<label for="usuario">Usuario:</labe>
<input type="text" id="usuario" value="" />

Para que tenhamos essa funcionalidade teremos que criar a seguinte classe.

namespace Controles {
public static class HtmlHelperBase
{
   public static string LabelTextbox(this HtmlHelper helper, string identificador, string label_texto, string tipo)
     {
          return String.Format("<label for='{0}'>{1}</label><input type='{2}' id='{3}' value='' />", identificador, label_texto, tipo, identificador);
     }
  }
}

Uma vez criada a classe, agora precisamos importar a namespace e utilizar o método criado em uma View. Veja o exemplo abaixo:

<%@ Page Language="C#" MasterPageFile="~/Views/Shared/Site.Master" AutoEventWireup="true" CodeBehind="Index.aspx.cs" Inherits="Mvc.Views.Home.Index" %>
<%@ Import Namespace="Controles" %>
  <asp:Content ID="indexContent" ContentPlaceHolderID="MainContent" runat="server">
<%= Html.LabelTextbox("usuario", "Aqui vem o texto", "text") %>

</asp:Content>

Bem simples e muito útil esse “poder” de personalização que temos.
Espero que tenham gostado. Em breve tem mais.

Pois é, já está disponível a versão Release Candidate do ASP.NET MVC e em breve (mais precisamente no próximo mês) deve ser liberada a versão 1.0 do MVC.

Bom, aqui você já pode encontrar dicas de como começar a estudar MVC e o LINQ nos posts:

• Usando LinqToSQL e MVC parte I
• Usando LinqToSQL e MVC parte II

E você pode ver mais sobre LINQ na categoria LINQ clicando aqui.

Espero que vocês gostem.

Bom, já estava na hora de finalizar esse post da utilização do MVC com LINQ To SQL.
Depois de mapearmos a tabela a ser utilizada no projeto, já podemos criar consultas, realizarmos inserções, alterações e exclusão de valores.

Listando as informações

Importe a namespace “Mvc.Models” (onde Mvc é o nome da namespace que estou utilizando).

Faça um foreach na classe “tb_cidade” em um ViewData. Escreva o nome da cidade atráves do “c.nome_cidade”.
Bom, esse código foi criado na página “Index.aspx” que é uma View, dentro da pasta Home. (View/Home/Index.aspx), preste atenção que Home é o nosso controle, então será nesse controle que iremos retornar os valores.

<%@ Page Language="C#" MasterPageFile="~/Views/Shared/Site.Master" AutoEventWireup="true" CodeBehind="Index.aspx.cs" Inherits="Mvc.Views.Home.Index" %>
<%@ Import Namespace="Mvc.Models" %>
<asp:Content ID="indexContent" ContentPlaceHolderID="MainContent" runat="server">
   <h2><%= Html.Encode(ViewData["Message"]) %></h2>
   <p>To learn more about ASP.NET MVC visit <a href="http://asp.net/mvc" title="ASP.NET MVC Website">http://asp.net/mvc</a>.</p>

   <ul>
     <% foreach (tb_cidade c in (IEnumerable)ViewData.Model)
     { %>
       <li><%= c.nome_cidade %></li>
     <% } %>
   </ul>
</asp:Content>

Bem simples né? Mas como essa informação foi preenchida neste ViewData?

Retornando os dados em um Controller

Devemos retornar os dados no Controller “HomeController.cs” que fica na pasta (Controllers/HomeController.cs).

Primeiro devemos importar a namespace “Mvc.Models”, depois devemos instanciar a classe LINQ To SQL criado anteriormente, neste caso o EstudoDataContext (Estudo.dbml).

Depois devemos montar nossa consulta LINQ.

IQueryable query = (from c in estudoDC.tb_cidades
select c);

Neste caso, estou retornando todos os dados da tabela “tb_cidades” em uma interface IQueryable.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Mvc.Ajax;
using Mvc.Models;

namespace Mvc.Controllers
{
  [HandleError]
  public class HomeController : Controller
  {
    public ActionResult Index()
    {
      EstudoDataContext estudoDC = new EstudoDataContext();
      IQueryable query = (from c in estudoDC.tb_cidades
                         select c);
      return View(query);
    }
  }
}

Agora sim, ficou fácil entender como conseguimos retornar esses dados para uma View.

Inserção, Alteração e Exclusão de informações

Veja abaixo os exemplos de insert, delete e update:

//Realizando um insert
tb_cidade cidade = new tb_cidade();
cidade.nome_cidade = "São Paulo";
estudoDC.tb_cidades.InsertOnSubmit(cidade);

//Realizando um delete
tb_cidade cidade = estudoDC.tb_cidades.Single(c => c.cidade_pk == 1);
estudoDC.tb_cidades.DeleteOnSubmit(cidade);

//Realizando um update
tb_cidade cidade = estudoDC.tb_cidades.Single(c => c.cidade_pk == 1);
cidade.nome_cidade = "Rio de Janeiro";

//Para qualquer uma das ações acima você deve comitar a alteração
//através do seguinte código
estudoDC.SubmitChanges();

Bem, caso vocês tenham alguma dúvida podem entrar em contato comigo, mas a idéia deste post foi como realmente implementar essas ações usando o MVC e LinqToSQL, e não explicar cada um das linhas detalhadamente.
Espero que tenham gostado. Em breve tem mais.

Vou mostrar hoje como utilizar Linq To SQL juntamente com o MVC para .NET Framework.

Não irei abordar neste post detalhes do que é Linq To SQL, nem mesmo aspectos relativos ao MVC para .NET, pois, a internet está cheia dessas informações. O principal objetivo deste post é mostrar como realizar o mapeamento de uma tabela, listar as informações, inserir, alterar e excluir registros usando Linq To SQL.

Irei dividir o post em duas partes:

Parte I

• Criação do projeto;
• Criação da classe Linq to SQL;
• Mapeamento do banco;

Parte II

• Inserção de valores;
• Atualização;
• Exclusão;
• Listagem de informações

Criação do projeto

Bom, vamos começar criando um projeto, no meu caso irei criar um projeto MVC Web application, mas você pode ficar a vontade e criar o projeto que quiser, pois, o processo de utilização do Linq é o mesmo.

Criação da Classe Linq to SQL

Assim que criarmos o projeto, devemos criar uma classe do tipo Linq to SQL. Para isso, clique com o botão na pasta Models (criada automaticamento com o MVC Web Application, ou se for um projeto comum crie dentro do App Code), Add new item, clique no sub-item Data e escolha um objeto do tipo Linq to SQL Classes. Dê o nome do arquivo de Estudo.dbml.

Mapeamento da tabela do projeto

Assim que criarmos uma classe do tipo Linq to SQL Classes, devemos criar a conexão com banco de dados.

Use o Server Explorer para conectar a base de dados, assim que a conexão for estabelecida, abra o item tables e arraste a tabela que deseja mapear. Para mapear diferentes tabelas basta arrastá-las para o Estudo.dbml (LinqToSQL Classes)

No meu caso, eu mapeie uma tabela que possui a seguinte estrutura:

Nome da Tabela: tb_cidade
Campos: cidade_pk, nome_cidade.

Com isso encerramos a primeira parte. Aguarde pela Parte II em breve, onde iremos listar, inserir, alterar e excluir informações usando LinqToSQL.

Espero que tenham gostado.