Entity Framework 4.1 - Primeiros Contatos

Entity Framework 4.1 - Code-First - Primeiros Contatos - (revisão)

E se eu dissesse para você que neste artigo vamos criar um banco de dados e duas tabelas: Categoria e Produto e vamos incluir dados na tabela Categoria.

E daí , o que tem de novo nisso ??? (você poderia pensar...)

É que vamos fazer isso sem usar nenhuma instrução SQL; antes vamos definir classes que serão mapeadas para nossas tabelas e tanto o banco de dados como as tabelas serão criadas automaticamente. Agora sim temos uma novidade certo ?

Tudo isso graças aos recursos do Entity Framework 4.1.

Dúvida ? Então continue lendo...

Esta é o um artigo que trata dos recursos do Entity Framework 4.1 dirigido para os iniciantes que estão tendo o seu primeiro contato com esta tecnologia.

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.. Em sua primeira versão, 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.

A Versão 4.1 do Entity Framework contém tanto a abordagem Code First e a nova API DbContext. Esta API fornece uma interface mais produtiva para trabalhar com o Entity Framework e pode ser usada com o seguintes padrões de desenvolvimento:

Code First - Criamos classes POCO que são mapeadas para as entidades;
Database First - Mapeamos para um Banco de dados que já existe;
Model First - Criamos o Modelo conceitual primeiro e depois é gerado o script para criar o banco de dados;

As classes POCO - POCO-Plain Old CLR Object - são classes simples de domínio que possuem apenas get/sets e um construtor e que não dependem de nenhum framework; as classes POCO não são obrigadas a herdar de nenhuma outra classe ou implementar nenhuma interface. Portanto as classes POCO são independente de frameworks.

Obs: Para que você se familiarize com os conceitos básicos do Entity Framework veja os artigos da seção Entity Framework do site Macoratti.net. Boa parte dos conceitos já abordados em outros artigos são repetidos aqui.

Portanto os destaques da versão 4.1 são:

API DbContext - Que nada mais é do que uma abstração simplificada do ObjectContext e diversos outros tipos introduzidos nas versões anteriores do Entity Framework. Esta API é otimizada para realizar as tarefas mais comuns e dar suporte a padrões de código como "Unit Of Work Pattern" e "Repository Pattern". A API DbContext é um invólucro para ObjectContext e além disso contém: Um conjunto de APIs que são mais fáceis de usar do que a exposta pelo ObjectContext e APIs que permitem utilizar o recurso do Code-First e as convenções;

Code First - É uma alternativa aos padrões "Database First" e "Model First" e esta baseado em classes POCO-(Plaind Old CLR Object) que são mapeadas para um banco de dados existente ou um banco de dados que será criado.

Então antes de dar qualquer passo você deve baixar a versão 4.1 do Entity Framework aqui: Versão 4.1 do Entity Framework

Recursos usados

Eu vou usar os seguintes recursos:

Visual Basic 2010 Express Edition
Linguagem Visual Basic .NET
Versão 4.1 do Entity Framework

Obs: Você deve ter o SQL Server 2008 Express Edition instalado

Objetivos

Neste primeiro artigo eu vou mostrar como usar o Code First (mais uma vez) para gerar o esquema do banco de dados , as tabelas e persistir dados.

Podemos usar Code First e apontar para um banco de dados existente ao invés de criar o banco de dados.(Este padrão é conhecido como DataBase First) A maneira mais fácil de de usar o Code First com um banco de dados existente é adicionar uma string de conexão ao arquivo App.Config ou arquivo Web.Config (para aplicações ASP .NET) que tenha o mesmo nome do seu DbContext derivado.
Exemplo:

Criando a aplicação

Abra o Visual Basic 2010 Express Edition (a versão gratuita do VB .NET) e no menu File selecione New Project;

A seguir escolha o modelo Windows Forms Application , informe o nome EF41_CodeFirst1 e clique em OK;

O seu projeto será criado.

Definindo o modelo

Vamos definir um modelo muito simples usando classes. Como estamos iniciando eu vou criar classes separadas no mesmo projeto mas o mais correto seria criar um projeto separado e nele criar as classes.

No menu Project selecione Add Class e a seguir informe o nome Categoria.vb e clique no botão Add;

A seguir defina o seguinte código para a classe Categoria:

Public Class Categoria

Public Property categoriaId As String
Public Property nome As String

End Class

Repita o processo acima e cria a classe Produto definindo nesta classe o código abaixo:

Public Class Produto

Public Property produtoId As String
Public Property nome As String
Public Property categoriaid As String
Public categoria As Categoria

End Class

O nosso modelo de negócio consiste de duas classes:

Produto
Categoria

O modelo de classes representa uma Categoria que possui 1 ou mais produtos e um Produto que pode esta associado a somente uma categoria.

Temos aqui uma associação que representa o relacionamento um-para-muitos. O relacionamento um-para-muitos é usado quando uma entidade A pode se relacionar com uma ou mais entidades B. Este relacionamento é representado pelo sinal: 1:N ou 1: * que expressa a cardinalidade do relacionamento.

A cardinalidade é um conceito importante para ajudar a definir o relacionamento, ela define o número de ocorrências em um relacionamento. Para determinar a cardinalidade, deve-se fazer a pergunta relativa ao relacionamento em ambas as direções. No exemplo a seguir, temos

Uma Categoria pode estar associada a quantos Produtos ? R: no mínimo 1 e no máximo N;
Um produto está alocado em quantos categorias ? R- no mínimo em 1 e no máximo em 1;

A maneira mais simples para começar a usar as classes para acesso a dados é definir um contexto que deriva de System.Data.Entity.DbContext e expõe um tipo DbSet (Of TEntity) para cada classe no meu modelo.

Vamos então usar os tipos a partir do EF 4.1 e para isso precisamos incluir uma referência ao assembly EntityFramework;

No menu Project selecione Add Reference e a seguir selecione a guia Browse e localize a pasta onde você instalou o Entity Framework 4.1;

A seguir selecione o assembly EntityFramework.dll e clique no botão OK;

Precisamos também incluir uma referência ao assembly do Entity Framework existente.

Repita o processo acima e selecione a guia NET e seguir procure pelo assembly System.Data.Entity selecione-o e clique em OK;

Agora vamos definir uma classe que irá usar o DbContext.

No menu Project selecione Add Class e a seguir informe o nome Contexto.vb e clique no botão Add;

A seguir defina o código abaixo neste classe:

Imports System.Data.Entity

Public Class Contexto

Inherits DbContext

Private m_Categorias As DbSet(Of Categoria)

Public Property Categorias() As DbSet(Of Categoria)

Get

Return m_Categorias

End Get

Set(ByVal value As DbSet(Of Categoria))

m_Categorias = value

End Set

End Property

Private m_produtos As DbSet(Of Produto)

Public Property Produtos() As DbSet(Of Produto)

Get

Return m_produtos

End Get

Set(ByVal value As DbSet(Of Produto))

m_produtos = value

End Set

End Property

End Class

Um dos recursos do EF 4.1 são as duas classes :
ObjectContext e ObjectSet;

- 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.

A nossa classe Contexto herda de DbContext e define as propriedades Categorias e Produtos.

Isso é tudo que você precisa para iniciar a persistência e a consulta aos dados.

Consultando e persistindo dados

Antes de partir para o código vamos incluir um controle ListBox no formulário form1.vb com o nome lsbResultado para podermos exibir os resultados obtidos.

O leiaute esta exibido na figura abaixo:

Vamos agora escrever o código que irá incluir uma nova categoria no banco de dados. Digite o código a seguir no formulário form1.vb do projeto:

Public Class Form1

Private Sub Form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load

Using db = New Contexto()

' Incluindo uma categoria no banco de dados
Dim bebida = New Categoria() With {.categoriaId = "BEBIDA", .nome = "Bebidas"}

        db.Categorias.Add(bebida)
        //persistindos as informações na tabela
        Dim registrosAfetados As Integer = db.SaveChanges()

       lsbResultado.Items.Add("Foram salvas " + Convert.ToString(registrosAfetados) + " entidade no banco de dados.")

End Using

End Sub

End Class

Neste código estou criando uma instância do contexto e a seguir criando uma nova categoria e incluindo-a na entidade Categoria para em seguida persistir as informações no banco de dados usando o método SaveChanges().

Pronto. Vamos executar, aguardar e aprender...

Após alguns segundos o resultado exibido será;

O que indica que o código foi executado e os dados foram persistidos.

Mas um momento !!!!

Onde estão o banco de dados e as tabelas visto que eu não criei o banco de dados nem a tabelas anteriormente ???

O que acontece é que o EF 4.1 , por trás dos panos, faz todo esse serviço. A API DbContext por convenção cria o banco de dados para você em localhost\SQLEXPRESS e o nome do banco de dados é derivado a partir do nome do projeto e do contexto, no nosso caso EF41_CodeFirst.Contexto.

Vamos verificar se isso é realmente verdade abrindo o SQL Server Management Studio e espiando o nosso SQL Server .

Abaixo vemos o banco de dados e as tabelas criadas bem como a categoria que foi incluída na tabela Categoria.

E como prometemos observando o código não vimos nenhuma instrução SQL.

Em resumo as tarefas realizadas pelo EF 4.1 foram:

Se conectou a uma instância do SQL Server na máquina local (.\SQLEXPRESS) usando a autenticação do Windows;
Verificou a existência do banco de dados com o nome qualificado da classe que herda de DbContext;
Descobriu as propriedades das classes Categoria e Produto;
Inferiu a existência do relacionamento um-para-muitos entre a classe Categoria e a classe Produto;
Criou as tabelas Categorias e Produtos com os tipos e os relacionamentos pertinentes;
Inclui os dados em cada uma das tabelas executando o comando SaveChanges();

Caramba !!! Como ele sabe fazer tudo isso sozinho ????

Elementar meu caro, ele usa as convenções pré-definidas.

E quais seriam então essas convenções ???

Segue um resumo :

Se você não definir um endereço para o servidor , o EF4 CTP5 irá tentar realizar uma conexão local;
O nome da tabela criada será o nome da classe no plural (usando a sintaxe da gramática da língua Inglesa.No exemplo: Alunoes e Cursoes);
Se não for definido um nome para o banco de dados , ele será criado com o nome do projeto mais o nome da classe do contexto;
Se uma classe tem uma propriedade de navegação para outra classe e esta possuir uma coleção da primeira, o EF infere que existe um relacionamento do tipo um-para-muitos entre as classes;
Se existe uma propriedade com nome igual ao nome da classe mas termina em Id ('nomeClasse'+Id) ou se o nome da propriedade é apenas Id esta propriedade será a chave primária;
Se a chave primária é do tipo inteiro ele é do tipo Identity;

Se você chegou até aqui e constatou como é simples trabalhar com acesso a dados usando o Entity Framework pode se interessar pelo próximo artigo onde irei mostrar do como criar uma aplicação ASP .NET com acesso a dados usando os recursos do Ef 4.1.

Pegue o projeto completo aqui : EF41_CodeFirst1.zip

"Como esta escrito: Não há um justo, nem um sequer. Não há ninguém que entenda; não há ninguém que busque a Deus." Rom. 10-11

Referências:

José Carlos Macoratti