ASP .NET - Criando uma aplicação MVC 3 com Entity Framework 4.1 usando Code First

Este artigo é uma adaptação do original - Building an MVC 3 App with Code First and Entity Framework 4.1 - de Julie Lernan.

O artigo mostra um passo a passo de como criar uma aplicação de blog usando as tecnologias ASP .NET MVC3, Entity Framework 4.1 e os recursos do Code First que é um modelo de desenvolvimento do Entity Framework 4.1.(EF 4.1)

O objetivo será criar partes de uma aplicação blog mostrando as características do Code First. Se você desejar pode concluir a aplicação adicionando todas as funcionalidades de um blog real.

Em resumo iremos realizar as seguintes tarefas:

O Entity Framework é uma ferramenta OR/M que realiza o mapeamento objeto relacional gerando entidades e mapeando-as para as tabelas do banco de dados.

Na primeira versão do Entity Framework praticamente não havia o que é conhecido como Code-First (Código Primeiro), ou seja, a possibilidade de gerar o modelo de negócios e suas entidades sem ter que primeiro criar o banco de dados.

Para quem trabalha usando o paradigma da orientação a objetos deveria ser natural iniciar o desenvolvimento pelo modelo de entidades, onde as classes são definidas para representar o domínio do negócio. Posteriormente, e a partir destas classes, seria gerado o banco de dados usado pela aplicação para realizar a persistência das informações.

Deveria ser assim, mas a primeira versão do EF não permitia esse recurso.

Tentando contornar este problema eram feitos certos malabarismos, mas ainda assim, havia uma dependência muito forte do mapeamento gerado pelo EF4 através do Entity Data Model, o que incomodava muita gente; até que a Microsoft liberou atualizações que permitem atualmente uma maior independência do Framework através da criação de classes POCO que não herdam das classes base geradas pelo EF.

Quando decidimos usar o Code-First não precisamos começar nossa aplicação criando o banco de dados ou definindo um esquema mas podemos iniciar escrevendo classes .NET para definir o modelo de objetos do nosso domínio sem ter que misturar a lógica de persistência de dados com as classes.

Os recursos necessários para acompanhar o artigo são:

Todos os recursos listados podem ser obtidos de forma gratuita.

Criando a aplicação ASP .NET MVC3

Abra o Visual Web Developer 2010 Express Edition (VWD 2010) e no menu File clique em New Project;

Na janela New Project selecione a linguagem de sua preferência (eu vou usar Visual Basic) e o template ASP .NET MVC 3 Web Application;

A seguir informe o nome MVCBlogCodeFirst, a localização do projeto e clique no botão OK;

Na janela do assistente selecione o item Internet Application e clique no botão OK;

Será criado um projeto com toda a estrutura já pronta contendo as classes do Controller, models e views:

Criando o modelo de classes para aplicação Blog

Vamos agora criar as classes para o nosso domínio , o nosso Model. Vamos criar as classes Blog, Post e Comment na pasta Models do projeto. Poderíamos criar 3 classes distintas mas para simplificar vou criar as 3 classes em um único arquivo.

- Clique com o botão direito sobre a pasta Models e selecione Add -> New Item;
- Em seguida selecione o template Class, informe o nome BlogClasses.vb e clique no botão Add;

- Digite na classe BlogClasses o código referente as 3 classes que representam o nosso domínio: Blog, Post e Coment

Criando um contexto no Entity Framework para gerenciar as classes e a interação com o banco de dados

Agora que já temos as classes, vamos precisar usar o Entity Framework para gerenciar as classes ao mesmo tempo que fornece acesso a dados e faça o controle de alterações de suas instâncias de objetos. A Classe DbContext do Entity Framework realiza este trabalho.

Vamos criar uma classe que herda de DbContext e sabe como servir e gerenciar os objetos Blog, Post, e Comment. O Entity Framework vai cuidar do mapeamento entre as classes e um banco de dados.

Para podermos usar o DbContext, temos que criar uma referência para a API do Entity Framework 4.1.

Obs: Se quando você instalou MVC 3, você adicionou o Nuget para Visual Studio 2010 voce vai poder encontrar facilmente os assemblies de referência a partir da internet.

- Clique com o botão direito do mouse sobre o projeto MVCBlogCodeFirst e clique em Add Reference;
- Na janela Add Reference clique na guia Browse e selecione o assembly EntityFramework.dll do local onde você instalou o Entity Framework 4.1 e clique em OK;

Vamos agora criar o nosso contexto usando o Entity Framework 4.1.

Crie uma nova classe chamada BlogContexto.vb selecionando a opção Add Class no menu Project;

Em seguida defina o seguinte código nesta classe:

O Entity Framework 4.1 traz como novidade uma versão simples das classes : ObjectContext e ObjectSet onde:

- ObjectContext permite consultar, controle de alterações e salvar no banco de dados.
- ObjectSet encapsula os conjuntos de objetos semelhantes.

O DbContext é um invólucro para ObjectContext e além disso esta classe contém:

- Um conjunto de APIs que são mais fáceis de usar do que a exposta pelo ObjectContext;
- As APIs que permitem utilizar o recurso do Code-First e as convenções;

O DbSet é um invólucro para ObjectSet e permite que na sua execução o banco de dados e as tabelas sejam criados com base na modelo definido.

O EF Code First permite que você conecte facilmente suas classes POCO do modelo em um banco de dados através da criação de uma classe "DbContext" que expõe propriedades públicas que mapeiam para tabelas do banco de dados. A classe BlogContexto acima ilustra como isso pode ser feito. Ela está mapeando nossas classes Blogs, Posts e Comments para as tabelas "Blogs", "Posts" e "Comments" no banco de dados.

As propriedades dentro das classes Blogs,Posts e Comments por sua vez mapeiam para colunas nas tabelas Bogs, Posts e Comments .

Dessa forma o banco de dados e as tabelas serão criados usando uma convenção padrão adotada pelo Entity Framework.

Criando a lógica do Controller para a classe Blog

Um controller coleta de dados, os envia para uma view e responde a pedidos da view. Vamos criar um controlador que usa a classe BlogContext para recuperar dados para nós. Em um aplicativo mais avançado, você deve separar essa lógica e não deveria trabalhar com a classe BlogContexto diretamente a partir do controlador.

Para a classe Blog, nós vamos criar uma view que apresenta uma lista de blogs disponíveis e outra que permite aos usuários criar novos blogs.

Portanto, o controlador vai precisar de um método para coletar uma lista de blogs para apresentar na primeira view, um outro método para fornecer uma view para inserir informações para um novo blog e, finalmente, um método para persistir o novo blog no banco de dados.

O modelo de projeto criou um controlador chamado Home com um conjunto de views e outro controlador chamado Account com seu próprio conjunto de views. Vamos ignorá-los e vamos criar os nossos próprios controladores e views, começando com um controlador para a classe Blog.

1- Realize um Build no projeto no menu Debug -> Build MVCBlogCodeFirst;
2- Na janela Solution Explorer clique com o botão direito do mouse sobre a pasta Controllers;
3- Selecione Add e a seguir Controller;
4- Na janela Add Controller, informe o nome do controller como BlogController e selecione o template para ler/escrever actions e views;
5- Selecione a classe Blog e a classe de contexto BlogContexto e clique no botão Add;

Será criada a classe BlogController na pasta Controllers contendo os métodos ActionResult:  Index, Details, Create, Edit e Delete.

O método Index deverá retornar uma lista de Blogs que serão exibidos na view:

Private db As BlogContexto = New BlogContexto

Function Index() As ViewResult
      Return View(db.Blogs.ToList())
End Function

No código acima estamos criando uma nova instância de BlogContexto que será usada para consultar Blogs e então retornar o resultado como uma lista de blogs.

Na linha de código : db.Blogs.ToList()

O Entity Framework trata de converter este comando em uma instrução SQL executando na consulta no banco de dados, capturando o resultado e transformando-os em objetos Blog.

Como não existe um banco de dados a metodologia Code-First irá criar o banco de dados e então executar o método Index.

Todas as views para o controller BlogController também foram criadas na pasta
Views -> Blog
  • Create.vbhtml
  • Delete.vbhtml
  • Details.vbhtml
  • Edit.vbhtml
  • Index.vbhtml

Observe a terminação .vbhtml que indica que estamos usando a sintaxe Razor para
a linguagem VB .NET.

Para que a view Index.vbhtml seja executada devemos alterar o arquivo
_Layout.vbhtml incluindo a seguinte linha de código:

<li>@Html.ActionLink("Blogs", "Index", "Blog")</li>

....
<div id="menucontainer">
<ul id="menu">
<li>@Html.ActionLink("Home", "Index", "Home")</li>
<li>@Html.ActionLink("Blogs", "Index", "Blog")</li>
<li>@Html.ActionLink("About", "About", "Home")</li>
</ul>
</div>
...

O código da view Index.vbhtml que usa sintaxe Razor e a página gerada pela sua execução podem ser vistos abaixo:

@ModelType IEnumerable(Of MVCBlogCodeFirst.Models.Blog)
@Code
ViewData("Title") = "Index"
End Code
<h2>Index</h2>
<p>
@Html.ActionLink("Criar Novo Blog", "Create")
</p>
<table>
<tr>
<th>Titulo</th>
<th>NomeBlogueiro</th>
<th>DataCriacao</th>
<th></th>
</tr>
@For Each item In Model
Dim currentItem = item
@<tr>
<td>
@Html.DisplayFor(Function(modelItem) currentItem.Titulo)
</td>
<td>
@Html.DisplayFor(Function(modelItem) currentItem.NomeBlogueiro)
</td>
<td>
@Html.DisplayFor(Function(modelItem) currentItem.DataCriacao)
</td>
<td>
@Html.ActionLink("Editar", "Editar", New With {.id = currentItem.Id}) |
@Html.ActionLink("Detalhes", "Details", New With {.id = currentItem.Id}) |
@Html.ActionLink("Deletar", "Delete", New With {.id = currentItem.Id})
</td>
</tr>
Next
</table>
Para exibir a view Index.vbhtml para exibir/criar/Deletar blogs basta
clicar na aba Blogs.

Observe que não temos nenhum blog cadastrado , e que para isso devemos clicar no link: Criar Novo Blog que irá executar o seguinte código:

@Html.ActionLink("Criar Novo Blog", "Create")

Este código executa a view Create.vbhtml que exibe a página vista na figura abaixo a direita:

@ModelType MVCBlogCodeFirst.Models.Blog
@Code
    ViewData("Title") = "Criar Novo Blog"
End Code
<h2>Criar novo BLog</h2>
<script src="@Url.Content("~/Scripts/jquery.validate.min.js")" type="text/javascript">
</script>
<script src="@Url.Content("~/Scripts/jquery.validate.unobtrusive.min.js")" type="text/javascript">
</script>
@Using Html.BeginForm()
    @Html.ValidationSummary(True)
    @<fieldset>
        <legend>Blog</legend>
        <div class="editor-label">
            @Html.LabelFor(Function(model) model.Titulo)
        </div>
        <div class="editor-field">
            @Html.EditorFor(Function(model) model.Titulo)
            @Html.ValidationMessageFor(Function(model) model.Titulo)
        </div>
        <div class="editor-label">
            @Html.LabelFor(Function(model) model.NomeBlogueiro)
        </div>
        <div class="editor-field">
            @Html.EditorFor(Function(model) model.NomeBlogueiro)
            @Html.ValidationMessageFor(Function(model) model.NomeBlogueiro)
        </div>
        <div class="editor-label">
            @Html.LabelFor(Function(model) model.DataCriacao)
        </div>
        <div class="editor-field">
            @Html.EditorFor(Function(model) model.DataCriacao)
            @Html.ValidationMessageFor(Function(model) model.DataCriacao)
        </div>
        <p>
            <input type="submit" value="Criar Blog" />
        </p>
    </fieldset>
End Using
<div>
    @Html.ActionLink("Retorna para Lista", "Index")
</div>
Para criar um novo Blog basta informar o titulo, nome do bloqueiro e
a data de criação , conforme exibe a figura, e clicar no botão -
Criar Blog.

Após criar um novo Blog retornamos a página Index.vbhtml que agora exibir o blog cadastrado e as opções para Editar, ver Detalhes e Deletar um blog.

Todo o código base para as demais views também foram criados e basta usar e verificar o resultado:

View Edit.vbhtml

Permite editar as informações de um blog.
View Details.vbhml

Permite ver as informações de um blog.
View Delete.vbhtml

Permite deletar as informações de um blog.

Mas fica um pergunta no ar !!!!

Cadê o banco de dados e as tabelas ???

Vamos conferir abrindo o SQL Server Management Studio 2008 Express Edition e espiando o banco de dados, as tabelas e o registro cadastrado:

Como esperado esta tudo lá...

Dessa forma o Entity Framework 4.1 e o Code First fez todo o trabalho pesado para nós, criando o banco de dados, tabelas e o assistente gerou o código para as views com base no nosso modelo e contexto. Para criar as demais páginas e código basta prosseguir usando o mesmo procedimento.

Eta vida boa...

Pegue o projeto completo aqui: MVCBlogCodeFirst.zip

"Porque há um só Deus, e um só Mediador entre Deus e os homens, Jesus Cristo homem." Timóteo 2-5

Referências:

José Carlos Macoratti