Você está na página 1de 35

Repositrio de Dados Genrico

02/05/2011 Fabio Alves Lopes 2 comentrios

Ol a todos. Neste post vamos conhecer um pouco sobre o padro repositrio (Repository
Pattern) e tambm vamos implementar um repositrio genrico que poder ser utilizado
para persistir as informaes de qualquer entidade do seu modelo de dados.

O nosso repositrio ser implementado utilizando a tecnologia Entity Framework (o


download da verso 4.1 RC pode ser feito aqui).

Utilizaremos o mesmo modelo implementado na srie Entity Framework Code First. Caso
voc no tenha visto estes posts, ou queira relembrar, clique aqui, aqui ou aqui. Sendo
assim, vamos levar em considerao que j sabemos como implementar as entidades
(classes de modelo) e o nosso contexto.

Repository Pattern

De acordo com Martin Fowler, o repositrio um mediador entre as camadas de domnio


e a camada de dados.

Mediates between the domain and data mapping layers using a collection-like interface
for accessing domain objects.

Sempre que houver a necessidade de alguma interao com o banco de dados, o


repositrio quem ser utilizado. O repositrio portanto ir conter todas as operaes que
dizem respeito a persistncia e acesso a dados, ou seja, ele ir conter os inserts, updates,
selects, etc. Com isto conseguimos prover o desacoplamento do cdigo, a separao
lgica das camadas, evitamos duplicidades no cdigo fonte, entre outros grandes
benefcios.

Implementao

Vamos criar uma nova Console Application com o nome RepositorioGenerico e adicionar
uma referncia a biblioteca do Entity Framework 4.1 RC. Vamos precisar adicionar
tambm uma referncia para System.ComponentModel.DataAnnotations.

Para simplificar, vamos implementar apenas a classe Cliente e a classe Contexto.

using System.ComponentModel.DataAnnotations;

namespace RepositorioGenerico
{
public class Cliente
{
[Key]
[DatabaseGenerated(DatabaseGeneratedOption.Identity)]
public int Id { get; set; }

[StringLength(50)]
public string Nome { get; set; }
[StringLength(50)]
public string Endereco { get; set; }
}
}
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Data.Entity.ModelConfiguration.Conventions;

namespace RepositorioGenerico
{
public class Contexto : DbContext
{
public DbSet<Cliente> Clientes { get; set; }

public Contexto()
{
Database.Connection.ConnectionString =
@"data source=fabio-pc\sql2008;
initial
catalog=RepositorioGenerico;
Integrated Security=SSPI";
}

protected override void OnModelCreating(DbModelBuilder


modelBuilder)
{

modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

modelBuilder.Conventions.Remove<IncludeMetadataConvention>();
}
}
}

No se esquea de trocar string de conexo, pois a mostrada acima esta apontando para a
minha instncia do SQL.

Para criarmos o banco de dados bastaria criar uma instncia do nosso contexto e
utilizarmos o mtodo Create() da propriedade Database. Caso quisssemos fazer alguma
interao com o banco de dados, como por exemplo incluir um novo registro de cliente,
bastaria instanciar o nosso contexto, criar um novo objeto de cliente, adicionar esse objeto
no contexto e salvar. Abaixo segue um exemplo simples destes mtodos para
relembrarmos.

private static void InserirNovoCliente()


{
var cliente = new Cliente()
{
Nome = "Nome Cliente",
Endereco = "Endereco Cliente"
};

var contexto = new Contexto();


contexto.Clientes.Add(cliente);
contexto.SaveChanges();
}

private static void CriarBancoDeDados()


{
var contexto = new Contexto();

if (!contexto.Database.Exists())
contexto.Database.Create();
}

A partir desse momento j possumos registros de clientes na base de dados, sendo assim
j podemos fazer consultas e trabalhar em cima dessas informaes. Bastaria escrever um
mtodo para consultar um determinado cliente pelo Id, ou at mesmo trazer uma lista de
clientes e trabalhar em cima dessas informaes.

Apesar de funcionar, o nosso cdigo de acesso a dados estaria sendo implementado junto
com a lgica de negcio da aplicao, causando um forte acoplamento, e por sua vez
tornando a manuteno desse cdigo uma tarefa bastante arriscada.

Imagine que haja vrios pontos do nosso sistema utilizando uma consulta de cliente pelo
Id, caso ocorra a necessidade de alguma manuteno nessa consulta, teramos que aplicar
a modificao em todos os locais onde a consulta foi implementada. Outro exemplo seria
a questo da persistncia dos dados no qual teramos que implementar um mtodo
especfico para cada entidade do nosso projeto, acarretando assim duplicidade de cdigo.
Utilizando um repositrio genrico, podemos centralizar os mtodos de persistncia e os
mtodos de consulta mais comuns, resolvendo assim o problema de duplicidade de
cdigo, separando a responsabilidade de acesso a dados da nossa lgica de negcios.

Como no estamos utilizando nenhum padro de arquitetura de software, tal como MVC
por exemplo, vamos apenas implementar o nosso repositrio em uma classe separada.

Implementando o repositrio genrico

O primeiro passo fazer com que o nosso repositrio receba um tipo genrico, que seriam
as nossas entidades. Em seguida vamos implementar os mtodos bsicos de persistncia
de dados (incluir, salvar, excluir) e tambm os bsicos de consulta (por chave primria/id
e todos os registros).

Precisamos que o nosso repositrio consiga atender todas as entidade do nosso sistema, e
caso haja a necessidade de uma implementao diferenciada, possamos herdar a classe,
implementar novos mtodos ou at mesmo sobrescrever os mtodos existentes. Para que
possamos sobrescrever os mtodos, os mesmos foram declarados como virtuais.

Segue abaixo um exemplo bsico de implementao do repositrio genrico.

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;

namespace RepositorioGenerico
{
public class Repositorio<T> where T : class
{
public DbContext Contexto { get; set; }

public Repositorio()
{
Contexto = new Contexto();
}

public virtual void Incluir(T entidade)


{
try
{
Contexto.Set<T>().Add(entidade }
catch (Exception ex)
{
throw new Exception(ex.Message);
}

Salvar();
}

public virtual void Salvar()


{
try
{
Contexto.SaveChanges();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}

public virtual void Excluir(T entidade)


{
try
{
Contexto.Set<T>().Remove(entidade
Contexto.SaveChanges();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}

public virtual T ObterPelaChavePrimaria(object[] chavePrimaria)


{
try
{
return Contexto.Set<T>().Find(chavePrimaria }
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}

public virtual IList<T> ObterTodos()


{
try
{
return Contexto.Set<T>().ToList }
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
}
}

Consideraes

Observe que a constraint where inserida na classe exige que o tipo genrico T seja uma
classe. Apesar de funcionar, caso seja passado um tipo que no seja uma entidade do
sistema, ser disparada uma exception, pois o contexto no vai reconhecer esse tipo. Para
evitarmos esse problema, devemos criar uma classe base com o nome Entidade por
exemplo, e fazer com que todas as entidades herdem dela. Dessa forma somente os tipos
que herdam de Entidade sero aceitos no repositrio.

namespace RepositorioGenerico
{
public abstract class Entidade
{
}
}

Como no vamos instanciar em momento algum a nossa classe Entidade, dizemos que
ela abstrata e que serve somente para fins de herana. Dentro da classe Cliente, basta
adicionar a herana na frente do nome da classe.

using System.ComponentModel.DataAnnotations;

namespace RepositorioGenerico
{
public class Cliente : Entidade
{

No repositrio basta trocar o tipo da constraint where para Entidade.

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;

namespace RepositorioGenerico
{
public class Repositorio<T> where T : Entidade
{

Observe tambm que todos os mtodos ou recebem um tipo genrico ou retornam um tipo
ou uma coleo genrica. Agora que j temos o nosso repositrio genrico implementado,
a sua utilizao ser bastante simples.

Dentro do mtodo Main da classe Program, crie uma instncia do repositrio passando o
tipo Cliente. Em seguida crie um novo objeto de Cliente e pea para o repositrio incluir
esse objeto no banco de dados.

namespace RepositorioGenerico
{
class Program
{
static void Main(string[] args)
{
var repositorio = new Repositorio<Cliente>();
var cliente = new Cliente()
{
Nome = "Nome Cliente",
Endereco = "Endereco Cliente",
};
repositorio.Incluir(cliente);
}
}
}

Caso quisssemos consultar um determinado registro no banco de dados e efetuar alguma


alterao, o cdigo seria bem simples. Vamos buscar um determinado cliente pelo seu Id
que a chave primria da tabela, em seguida vamos alterar o nome deste cliente e depois
persistir as modificaes no banco de dados.

namespace RepositorioGenerico
{
class Program
{
static void Main(string[] args)
{
var repositorio = new Repositorio<Cliente>();
var cliente = repositorio.ObterPelaChavePrimaria(new
object[]{1});
cliente.Nome = "Nome Cliente Alterado";

repositorio.Salvar();
}
}
}

Caso houvesse a necessidade da criao de um mtodo que retornasse todos os clientes


ordenados pelo nome, bastaria criarmos um repositrio especfico para clientes herdando
o nosso repositrio genrico. O cdigo ficaria da seguinte forma.

using System.Collections.Generic;
using System.Linq;

namespace RepositorioGenerico
{
public class RepositorioCliente : Repositorio<Cliente>
{
public IList<Cliente> ObterTodosOrdenadoPeloNome()
{
return ObterTodos().OrderBy(x => x.Nome).ToList();
}
}
}
namespace RepositorioGenerico
{
class Program
{
static void Main(string[] args)
{
var repositorio = new RepositorioCliente();
var clientes = repositorio.ObterTodosOrdenadoPeloNome();
}
}
}

Nada impede de que a implementao do repositrio especfico seja deixada de lado e


que a ordenao seja feita a partir da coleo retornada pelo repositrio genrico, porm
podem acontecer situaes onde essa consulta seja necessria em outros lugares do
sistema, logo teremos duplicidade de cdigo novamente.

O exemplo que foi apresentado extremamente simples, porm serve como um pontap
inicial para aqueles que ainda no conheciam o padro ou para aqueles que esto iniciando
na sua utilizao.

Espero que tenham gostado do post.

No deixem de comentar, a opinio de vocs muito importante.

At o prximo

Categorias:.NET, EntityFramework Tags:C#, CodeFirst, Entity Framework, Generics,


Repository Pattern

Criando um Tipo Genrico Dinamicamente


21/04/2011 Fabio Alves Lopes 2 comentrios

Gostaria de compartilhar com vocs uma situao na qual me deparei recentemente e que
por um momento cheguei a pensar que no tinha soluo.

O cenrio

O projeto possua diversas classes, no qual cada uma representava uma entidade dentro
do sistema. Para efetuar as consultas no banco de dados, deveria ser implementada uma
nica classe de consulta, na qual seria um tipo genrico, e a partir dai ela tinha que se
virar com o resto. Vocs devem estar se perguntando qual a dificuldade nisso no ?
Realmente no h dificuldade alguma, basta aplicar o conceito de Generics.

Como no h a necessidade de implementar diversas classes para ilustrar o problema,


vamos implementar uma nica classe, muito simples, que vai representar a entidade
cliente.

Implementando

Vamos criar um novo projeto do tipo Console Application com o nome ProjetoConsulta.
Insira uma nova classe no projeto chamada Cliente. Segue abaixo o cdigo da classe.

namespace ProjetoConsulta
{
public class Cliente
{
public int Id { get; set; }
public string Nome { get; set; }
}
}

Agora vamos criar a nossa classe de consulta genrica, na qual vamos implementar um
nico mtodo, para fins ilustrativos, que vai apenas exibir uma frase com o nome do tipo
genrico que foi passado para a consulta.

using System;

namespace ProjetoConsulta
{
public class Consulta<T>
{
public Consulta()
{
}

public void Consultar()


{
Console.WriteLine("Consultando dados de {0}",
typeof(T).Name);
Console.ReadKey();
}
}
}

Nesse momento, utilizarmos a nossa consulta genrica seria uma tarefa simples. Bastaria
instanciarmos a nossa classe Consulta e invocarmos o mtodo Consultar(). Para isso, v
at a nossa classe Program e dentro do mtodo principal implemente o seguinte cdigo.

namespace ProjetoConsulta
{
class Program
{
static void Main(string[] args)
{
var consulta = new Consulta<Cliente>();
consulta.Consultar();
}
}
}

Como vocs podem ver, instanciamos a nossa classe Consulta e passamos o tipo Cliente
para a mesma. Basta compilar o programa e vamos obter o seguinte resultado.
Problema

Como a vida de programador nunca to simples assim, tem sempre aquele detalhezinho
que aparece no final para deixar tudo mais divertido, no ?

Depois que todas as classes estavam implementadas e toda a regra de negcio j definida,
surgiu um novo requisito, no qual o sistema teria que ser ser capaz de utilizar a consulta
genrica sabendo apenas o nome (uma string) do tipo que seria utilizado.

Primeira tentativa

namespace ProjetoConsulta
{
class Program
{
static void Main(string[] args)
{
var nomeDoTipo = "Cliente";

var consulta = new Consulta<nomeDoTipo>();


consulta.Consultar();
}
}
}

claro que no vai funcionar, pois temos que passar um tipo e no uma string que
contenha apenas o nome desse tipo.

Bom, se temos apenas uma string com o nome do tipo, mas precisamos saber o tipo e no
o nome, ento vamos utilizar Reflection para criarmos um objeto a partir desse nome, e
consequentemente, podemos obter o tipo do objeto criado.

Segunda tentativa

using System;
using System.Reflection;

namespace ProjetoConsulta
{
class Program
{
static void Main(string[] args)
{
var nomeDoTipo = "Cliente";
var nomeDoAssembly =
Assembly.GetExecutingAssembly().GetName().Name;
var nomeCompleto =
string.Format("{0}.{1}", nomeDoAssembly, nomeDoTipo);

var objeto =
Activator.CreateInstance(Type.GetType(nomeCompleto));
var tipoDoObjeto = objeto.GetType();

var consulta = new Consulta<tipoDoObjeto>();


consulta.Consultar();
}
}
}

Infelizmente no deu certo, vamos desistir?

No, no!, sou brasileiro e no desisto nunca!

Vamos ser pacientes e pensarmos um pouquinho mais, pois estamos no caminho certo. J
temos o tipo que vai ser passado para a consulta, porm no conseguimos instanciar a
consulta informando o tipo dessa maneira.

Terceira tentativa

Observando as opes que eram apresentadas atravs do cdigo objeto.GetType(), acabei


encontrando mtodo MakeGenericType(), que retorna um tipo genrico. (O pior que
esse mtodo j existia desde a verso 2.0 do framework).

Bom, sendo assim, temos que instanciar a nossa classe Consulta tambm por Reflection
e dizer que ela um tipo genrico, e que do tipo Cliente. Segue abaixo o cdigo.

using System;
using System.Reflection;

namespace ProjetoConsulta
{
class Program
{
static void Main(string[] args)
{
var nomeDoTipo = "Cliente";
var nomeDoAssembly =
Assembly.GetExecutingAssembly().GetName().Name;
var nomeCompleto =
string.Format("{0}.{1}", nomeDoAssembly, nomeDoTipo);

var objeto =
Activator.CreateInstance(Type.GetType(nomeCompleto));
var tipoDoObjeto = objeto.GetType();

var tipoDaConsulta =
typeof(Consulta<>).MakeGenericType(tipoDoObjeto);

var consulta = Activator.CreateInstance(tipoDaConsulta);


consulta.Consultar();
}
}
}

Agora, sim, conseguimos instanciar dinamicamente a classe Consulta, e ela do tipo


Cliente. Pena que ainda no vai funcionar, pois como a minha varivel consulta recebeu
um objeto do tipo object e no um tipo definido Consulta<T>, teremos acesso apenas aos
mtodos de object. Para que possamos acessar o mtodo, existem duas formas:

Primeira forma Dynamic

Se a nossa varivel consulta fosse do tipo dynamic, o compilador no iria verificar se o


mtodo Consultar() existe no momento da compilao, e o mesmo s seria requisitado
em tempo de execuo. Basta fazer a seguinte modificao no cdigo.

//Troque
//var consulta = Activator.CreateInstance(tipoDaConsulta);
//Por
dynamic consulta = Activator.CreateInstance(tipoDaConsulta);
consulta.Consultar();

Apesar de funcionar sem problemas, particularmente no recomendo esse tipo de


utilizao. Se futuramente o mtodo Consultar() dentro da classe Consulta passar a
receber algum parmetro, o compilador no ter a capacidade informar que essa chamada
deve ser adaptada, consequentemente teremos um erro no cdigo, e o mesmo s ser
percebido em tempo de execuo, deixando os nossos clientes muito felizes.

Segunda forma Cast

Temos que transformar o object que retornado atravs do Reflection em um objeto do


tipo Consulta<T>. Infelizmente no vamos conseguir fazer um Cast diretamente porque
a nossa classe Consulta um tipo genrico e ainda por cima a instanciamos
dinamicamente. Logo, os seguintes trechos de cdigo no se aplicam.

//Falta o parmetro
//var consulta = (Consulta)Activator.CreateInstance(tipoDaConsulta);

//Falta o argumento
//var consulta = (Consulta<>)Activator.CreateInstance(tipoDaConsulta);

//Argumento no existe
//var consulta = (Consulta<T>)Activator.CreateInstance(tipoDaConsulta);

//No pode pois tudo dinmico e no conhecemos o tipo, apenas o nome


//var consulta =
(Consulta<Cliente>)Activator.CreateInstance(tipoDaConsulta);

Sendo assim, podemos criar uma interface e fazermos com que a nossa classe Consulta
implemente essa interface.

Para criarmos uma interface, basta adicionar um novo item ao nosso projeto, e selecionar
o tipo Interface. Caso haja dvidas quanto a criar uma interface, voc pode adicionar uma
nova classe e trocar o tipo class por interface. Abaixo segue o cdigo para facilitar.
namespace ProjetoConsulta
{
public interface IConsulta
{
void Consultar();
}
}

Como j implementamos o mtodo Consultar() na classe Consulta, no haver


necessidade de modificar a sua estrutura. Devemos apenas dizer que a classe Consulta
implementa a interface IConsulta.

using System;

namespace ProjetoConsulta
{
public class Consulta<T> : IConsulta
{
public Consulta()
{
}

public void Consultar()


{
Console.WriteLine("Consultando dados de {0}",
typeof(T).Name);
Console.ReadKey();
}
}
}

Pronto, agora podemos fazer o Cast, passando o objeto retornado para um tipo abstrato
(nossa interface IConsulta) e acessar o mtodo que foi implementado no tipo concreto
(nossa classe Consulta).

using System;
using System.Reflection;

namespace ProjetoConsulta
{
class Program
{
static void Main(string[] args)
{
var nomeDoTipo = "Cliente";
var nomeDoAssembly =
Assembly.GetExecutingAssembly().GetName().Name;
var nomeCompleto =
string.Format("{0}.{1}", nomeDoAssembly, nomeDoTipo);

var objeto =
Activator.CreateInstance(Type.GetType(nomeCompleto));
var tipoDoObjeto = objeto.GetType();

var tipoDaConsulta =
typeof(Consulta<>).MakeGenericType(tipoDoObjeto);

var consulta =
(IConsulta)Activator.CreateInstance(tipoDaConsulta);
consulta.Consultar();
}
}
}

Pronto, finalmente vai funcionar. Compile o programa e veja o resultado.

Muito legal, no ?

Espero que tenham gostado do post e que de alguma forma possa ter ajudado. No deixem
de comentar, a opinio de vocs muito importante.

At o prximo

Categorias:.NET, Reflection Tags:C#, Dynamic, Generics, Reflection

Entity Framework Code First Parte 3


13/04/2011 Fabio Alves Lopes 12 comentrios

Ol novamente pessoal. Nesta terceira parte vamos dar continuidade a nossa pequena
aplicao utilizando a tecnologia Entity Framework utilizando o conceito de Code First.

No post anterior, vimos como conectar a nossa aplicao com o banco de dados e vimos
tambm o Entity Framework gerando a nossa estrutura de tabelas. Na realidade geramos
somente a tabela Filme para exemplificar, visto que era a nica classe que havamos
implementado dentro da nossa aplicao. Para aqueles que esto chegando agora ou que
querem relembrar, basta clicar aqui ou aqui.

Os posts anteriores so de grande importncia para aqueles que esto comeando, seja no
mundo .NET, trabalhar com o Entity Framework ou at mesmo iniciando sua jornada
como desenvolvedores de softwares.

Dando continuidade ao projeto

Como vocs devem ter notado, apesar de eu ter dito que a aplicao seria um exemplo
simples e que no iria servir para atender uma locadora de verdade, ainda esto faltando
informaes que so muito importantes e bsicas para a regra de negcio da empresa.

Do que voc esta falando?

Vamos analisar friamente a presente situao: At o momento a nossa aplicao s


conhece informaes relacionadas a filmes, porm isso no suficiente para que uma
empresa que atua no ramo de locao de filmes possa funcionar. O que falta ento?

Claro, falta aquela entidade do mundo real que leva o filme para o aconchego de sua
residncia e ento o assiste, estamos falando do cliente. O sistema tem que armazenar as
informaes dos clientes, logo temos que implementar a nossa classe Cliente. Esta classe
vai ser to simples quanto a nossa classe Filme, vamos ter apenas 3 informaes para o
nosso exemplo: id, nome e endereo. Segue abaixo o cdigo.
using System.ComponentModel.DataAnnotations;

namespace ExemploEF.Inicio
{
public class Cliente
{
[Key]
[DatabaseGenerated(DatabaseGeneratedOption.Identity)]
public int Id { get; set; }

[StringLength(50)]
public string Nome { get; set; }

[StringLength(50)]
public string Endereco { get; set; }
}
}

Agora precisamos fazer com que a classe Contexto possa ter colees da nossa classe
Cliente. Vamos adicionar outra propriedade do tipo DbSet (basta seguir o mesmo
procedimento feito para a classe Filme).

Bom, j temos duas entidades importantes que fazem parte da regra de negcios, logo
podemos imaginar o seguinte cenrio: O cliente chega, entra pela porta, vai at o
expositor, pega o filme e vai embora. (?) Tem algo errado ai, no tem?

Tem sim! De forma bem resumida o cenrio correto seria este aqui: O cliente chega, entra
pela porta, vai at o expositor, pega o filme, se dirige at o balco, informa seus dados
pessoais e os filmes desejados para a balconista, paga ou no ou nunca a conta, pega os
filmes e vai embora. suposto que o cliente volte na data combinada, devolva os filmes
e pague a conta, caso ainda no tenha pago.

bvio que o cenrio apresentado foi muito simples e continha informaes que no
eram relevantes para o funcionamento do sistema, porm a inteno era identificar a nossa
terceira entidade, a classe Locacao.

A classe Locacao

Apesar de ser uma classe bastante simples, a mesma vai agrupar informaes muito
importantes, visto que quase tudo em uma locadora de filmes iniciasse a partir da ao
locar um filme. A nossa classe deve conter as informaes bsicas referentes a uma
locao como por exemplo os dados do nosso cliente e os dados dos filmes que foram
locados, assim como a data de devoluo, o valor referente a locao e algo que possa
indicar se o cliente j efetuou o pagamento. Outro detalhe importante o fato de haver
mais de um filme envolvido no processo de locao, com isso, encontramos nossa quarta
e ultima entidade, os itens da locao (LocacaoItem).

Vamos implementar a nossa classe Locacao.

using System;
using System.Collections.ObjectModel;
using System.ComponentModel.DataAnnotations;

namespace ExemploEF.Inicio
{
public class Locacao
{
[Key]
[DatabaseGenerated(DatabaseGeneratedOption.Identity)]
public int Id { get; set; }

public DateTime DataDevolucao { get; set; }

public decimal TotalPrecoDeLocacao { get; set; }

public bool LocacaoJaFoiPaga { get; set; }

public int ClienteId { get; set; }

public virtual Cliente Cliente { get; set; }

public virtual ObservableCollection<LocacaoItem> LocacaoItens


{get;set;}
}
}

A nossa classe Locacao possui duas caractersticas que at o momento no haviam sido
abordadas. Como vocs podem perceber, ela possui uma propriedade do tipo Cliente e
uma coleo de LocacaoItem.

Atravs da propriedade Cliente, vamos conseguir acessar/inserir os dados do cliente.


Vocs devem estar se perguntando o porque eu criei a propriedade do tipo inteiro
ClienteId. A resposta simples: Ns poderamos sim ter omitido essa propriedade porm
muito mais interessante que ns tenhamos o controle sobre as minhas chaves
estrangeiras, logo vocs vo entender.

Agora vamos implementar a nossa classe LocacaoItem.

using System.ComponentModel.DataAnnotations;

namespace ExemploEF.Inicio
{
public class LocacaoItem
{
[Key]
[Column(Order = 0)]
public int LocacaoId { get; set; }

[Key]
[Column(Order = 1)]
public int FilmeId { get; set; }

public virtual Filme Filme { get; set; }

public decimal PrecoDeLocacao { get; set; }


}
}

Como vocs podem ver, eu tenho uma propriedade do tipo Filme, na qual eu vou poder
acessar/setar os dados dos filmes, e possuo tambm uma propriedade FilmeId do tipo
inteiro. Nesse caso, eu quero que tanto o LocacaoId quanto o FilmeId sejam minha chave
primria nessa tabela, ou seja, no haver a possibilidade de repetir um filme em uma
determinada locao. Outro detalhe importante que o Entity Framework j sabe que as
propriedades LocacaoId e FilmeId pertencem as classes Locacao e Filme.

Agora s falta fazer os ltimos ajustes na nossa classe Contexto e a nossa estrutura estar
pronta. Segue abaixo o cdigo.

using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Data.Entity.ModelConfiguration.Conventions;

namespace ExemploEF.Inicio
{
public class Contexto : DbContext
{
public DbSet<Filme> Filmes { get; set; }
public DbSet<Cliente> Clientes { get; set; }
public DbSet<Locacao> Locacoes { get; set; }
public DbSet<LocacaoItem> LocacaoItens { get; set; }

public Contexto()
{
Database.Connection.ConnectionString =
@"data source=fabio-pc\sql2008;
initial catalog=ExemploEF;
Integrated Security=SSPI";
}

protected override void OnModelCreating(DbModelBuilder


modelBuilder)
{

modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

modelBuilder.Conventions.Remove<IncludeMetadataConvention>();
}
}
}

Qual o resultado final disso tudo?

O resultado final muito interessante, devo confessar que meus olhos brilharam no
momento em que vi pela primeira vez. Para aqueles que tiverem uma noo bsica sobre
estrutura de banco de dados, aposto que vo ter a mesma reao.

Vamos compilar a nossa aplicao e conferir atravs do Management Studio.


Show de bola no ?

Inserindo os nossos primeiros registros no banco de dados

Vamos escrever um outro mtodo na classe Program (Console Application) que vai
inserir dois filmes e dois clientes no banco de dados.

namespace ExemploEF.Inicio
{
class Program
{
private static Contexto contexto;

static void Main(string[] args)


{
contexto = new Contexto();

ResetarBancoDeDados();

InserirNovosCadastros();
}

public static void ResetarBancoDeDados()


{
if (contexto.Database.Exists())
contexto.Database.Delete();
contexto.Database.Create();
}

public static void InserirNovosCadastros()


{
//Filmes
contexto.Filmes.Add(new Filme
{
Titulo = "Filme 1",
PrecoDeLocacao = 2.5m
});
contexto.Filmes.Add(new Filme
{
Titulo = "Filme 2",
PrecoDeLocacao = 2
});

//Clientes
contexto.Clientes.Add(new Cliente
{
Nome = "Cliente 1",
Endereco = "Endereco Cliente
1"
});
contexto.Clientes.Add(new Cliente
{
Nome = "Cliente 2",
Endereco = "Endereco Cliente
2"
});

contexto.SaveChanges();
}
}
}

Como vocs podem ver no mtodo InserirNovosCadastros(), estamos adicionando em


nosso contexto dois filmes e dois clientes. O fato interessante que at esse momento
essas quatro novas entidades estavam alocadas na memria e s foram inseridas no banco
de dados aps a execuo do mtodo SaveChanges() do contexto. Caso queira confirmar,
faa uma consulta atravs do Management Studio.
Funcionou! O que mais podemos fazer?

Agora vamos escrever outro mtodo onde vamos fazer uma alterao em algum registro
que esteja inserido em nosso banco de dados. Vamos trocar o nome do Cliente 2 para
Cliente 2 Legal. Utilizaremos trs passos simples para fazer essa tarefa:

Primeiro: vamos obter o nosso cliente na base de dados.

Segundo: vamos alterar o nome atravs do objeto que vai conter as informaes do
cliente.

Terceiro: vamos persistir essas informaes no banco de dados.

A t, e como que se faz uma consulta?

Muito simples, vamos utilizar consultas LINQ (Language-Integrated Query).

LINQ?

um conjunto de recursos que permite ao desenvolvedor fazer consultas em fontes de


dados utilizando uma sintaxe nica, ou seja, a mesma sintaxe que utilizada para fazer
consultas em um banco de dados SQL pode ser utilizada em uma lista de objetos, em um
arquivo XML, etc. Caso haja dvidas quanto a isso, pergunte ao Orculo.

Para que isso seja possvel, devemos acrescentar o using System.Linq no topo da nossa
classe Program. O cdigo do mtodo segue abaixo.

public static void AlterarNomeDoCliente2()


{
var cliente = (from x in contexto.Clientes
where x.Nome == "Cliente 2"
select x).FirstOrDefault();

cliente.Nome = "Cliente 2 Legal";

contexto.SaveChanges();
}

Podemos notar que a nossa varivel cliente esta recebendo o resultado de uma consulta
LINQ diretamente em uma fonte de dados, que no caso o nosso contexto. Perceba
tambm que essa consulta possui a clusula where que tem a mesma finalidade da que
existe no SQL.

Eu particularmente gosto muito de utilizar Lambda Expressions nas minhas consultas


LINQ, pois fica ainda mais fcil de entender o que esta acontecendo. Segue abaixo o
nosso mtodo utilizando tal recurso.

public static void AlterarNomeDoCliente2()


{
var cliente =
(contexto.Clientes.Where(x => x.Nome == "Cliente
2")).FirstOrDefault();

cliente.Nome = "Cliente 2 Legal";

contexto.SaveChanges();
}

Faa a chamada para este mtodo no Main da nossa classe Program, e caso queira,
coloque um BreakPoint no incio do mtodo AlterarNomeDoCliente2() para observarmos
as informaes da varivel cliente.

Antes

Depois

Tnhamos a nossa varivel cliente preenchida com as informaes do nosso cliente l do


banco de dados. Em seguida a propriedade Nome foi alterada. Depois do contexto salvar
as mudanas, o nosso cliente j vai estar atualizado no banco de dados.
Agora vamos escrever um mtodo para excluir o nosso cliente que possui o id igual a 2,
que o mesmo que alteramos o nome anteriormente.

public static void ExcluirOCliente2()


{
var cliente = contexto.Clientes.Find(2);

contexto.Clientes.Remove(cliente);

contexto.SaveChanges();
}

Como Id a chave primria da nossa tabela Cliente, eu utilizei o mtodo Find() que busca
um registro no banco de dados atravs da sua chave primria. Nada impede de seja escrita
uma consulta LINQ, porm se j existe algo pronto, vamos aproveitar!

Na segunda parte do mtodo, estamos removendo o cliente do nosso contexto e em


seguida estamos persistindo essa informao no banco de dados. Muito simples no ?

Faa a chamada para o mtodo ExcluirOCliente2() no Main da nossa classe Program e


compile o programa.

O grande potencial do Entity Framework

Estamos prestes a ver o quo interessante o nosso amiguinho pode ser. Vamos criar um
mtodo que vai fazer com que o nosso Cliente 1 alugue dois filmes. Os passos a serem
seguidos so:

Primeiro: obter as informaes do cliente com nome Cliente 1.

Segundo: obter as informaes referentes ao Filme 1 e Filme 2.

Terceiro: criar uma nova locao passando as informaes obtidas nos passos anteriores.

Quarto: adicionar a nossa locao ao contexto.

Quinto: persistir as informaes no banco de dados.

Muita gente deve estar se perguntando agora o porque eu no criei um projeto de testes
para mostrar esses exemplos. A resposta vai ser exatamente igual a de quando falei sobre
os Data Annotations no post anterior: Testes unitrios so carinhas bem legais e
merecem um post especial.

A implementao do nosso mtodo ficaria da seguinte forma.

public static void LocarFilme()


{
//Selecionar o cliente
var cliente =
(contexto.Clientes.Where(x => x.Nome == "Cliente
1")).FirstOrDefault();

//Selecionar os filmes
var filme1 =
(contexto.Filmes.Where(x => x.Titulo == "Filme
1")).FirstOrDefault();
var filme2 =
(contexto.Filmes.Where(x => x.Titulo == "Filme
2")).FirstOrDefault();

//Locar
var locacao = new Locacao
{
Cliente = cliente,
DataDevolucao = DateTime.Today.AddDays(2),
LocacaoJaFoiPaga = true,
LocacaoItens = new ObservableCollection<LocacaoItem>
{
new LocacaoItem {Filme = filme1, PrecoDeLocacao =
filme1.PrecoDeLocacao},
new LocacaoItem {Filme = filme2, PrecoDeLocacao = 1.5m}
}
};
locacao.TotalPrecoDeLocacao = locacao.LocacaoItens.Sum(x =>
x.PrecoDeLocacao);

contexto.Locacoes.Add(locacao);
contexto.SaveChanges();
}

Notem que no momento que estamos criando uma nova locao, passamos o objeto
cliente para a propriedade Cliente, automaticamente o Entity Framework j sabe o que
fazer. Para a minha coleo LocacaoItens, so criados dois novos LocacaoItem (o valor
do Filme 1 continua sendo o preo que estava no cadastro, j o preo de locao do Filme
2 foi alterado).

Outro fato interessante que j foi possvel obter o preo total da locao utilizando LINQ
com Lambda Expressions em cima da coleo LocacaoItens que acabou de ser inserida
na memria.

Confira o resultado no banco de dados atravs do Management Studio.

E agora, o que falta?

Agora precisamos criar uma interface grfica para a nossa aplicao, afinal de contas ela
no pode funcionar somente atravs de uma Console Application.

No post anterior eu havia dito que iriamos dividir a nossa aplicao em camadas, porm
eu acredito que vai ficar muito mais interessante se isso acontecer no quarto post da srie.

Espero que tenham gostado dessa terceira parte, e que tenha sido de alguma utilidade ou
ajuda.

No deixem de fazer comentrios sobre os posts, a opinio de vocs muito importante.

At mais
Categorias:.NET, EntityFramework Tags:C#, CodeFirst, CodeOnly, Entity Framework

Entity Framework Code First Parte 2


12/04/2011 Fabio Alves Lopes 8 comentrios

Ol galera, vamos dar continuidade a nossa pequena aplicao utilizando a tecnologia


Entity Framework utilizando o conceito de Code First.

No post anterior, expliquei de forma bem resumida o conceito, criamos a nossa primeira
classe Filme e criamos tambm o nosso contexto. Para quem ainda no leu, ou quiser
relembrar, basta clicar aqui.

Bom, como eu havia prometido, vamos colocar uma parte da aplicao para funcionar,
ou seja, vamos fazer com que a nossa aplicao interaja com o banco de dados. Para que
isso seja possvel, necessrio que voc tenha alguma verso do Microsoft SQL Server
instalada ou pelo menos esteja instalada em alguma mquina da rede, de forma que voc
consiga acessar esse banco e tenha permisso para fazer alteraes.

Vale lembrar que se voc for utilizar SQL Server de alguma outra mquina, talvez seja
necessrio fazer algumas configuraes de permisso e portas no Firewall da mquina
que ter a funo de servidor. Caso haja dvidas quanto aos procedimentos (instalao e
configurao), basta fazer uma consulta ao Orculo. Existem inmeros sites, blogs que
sero bastante teis.

Particularmente, estou utilizando a verso Express do Microsoft SQL Server, totalmente


gratuita e no deixa nada a desejar. Caso voc queira baixar e instalar na sua mquina,
clique aqui. Para visualizar a estrutura e os dados eu utilizo o Management Studio, que
uma ferramenta nativa do SQL Server, ou seja, j vem junto com a instalao da verso
Express.

Sendo assim, deste ponto a diante, vou levar em considerao que todos ns j instalamos
e configuramos o nosso servidor SQL.

Como que a nossa aplicao se comunica com o banco de dados?

Como estamos falando de Microsoft Visual Studio + Microsoft SQL Server, no h


necessidade de drivers externos para que a mgica acontea, vamos utilizar apenas um
texto que contm as informaes de acesso, conhecido como string de conexo.

A string de conexo possui o seguinte formato:

data source={InstanciaDoSQL}; initial catalog={BancoDeDados}; user id={Usuario};


password={Senha}

No meu caso, eu sempre utilizo o SQL Server Authentication, com o usurio sa do SQL
Server, porm se voc encontrar dificuldades em fazer a configurao do usurio, voc
pode optar por utilizar o Windows Authentication, no qual no necessrio passar o
usurio e a senha.
data source={InstanciaDoSQL}; initial catalog={BancoDeDados}; Integrated
Security=SSPI

Voc pode conectar a sua aplicao utilizando um arquivo de configurao (app.config)


ou voc pode passar a string de conexo diretamente para o contexto. As duas formas so
muito simples, porm vou optar pela segunda forma por ser mais prtica.

Preparando o nosso contexto para se conectar ao banco de dados

Abra a sua classe Contexto, e agora vamos criar um constructor para ela. Dentro do
constructor vamos acessar a propriedade de conexo com o banco de dados e vamos
passar a nossa string personalizada.

O passo seguinte sobrescrevermos o mtodo OnModelCreating do contexto para


fazermos dois pequenos ajustes. O primeiro ajuste ser remover a pluralizao de nome
de tabelas quando o sistema gerar o banco de dados.

Pluralizao de nome de tabelas? Sim, imagine que temos a nossa classe Livro, no
momento em que o banco for criado, a tabela ter o nome Livros, at ai nenhum problema.
Porm quando formos criar a nossa classe Locacao (poxa vida, estraguei a surpresa), o
nome da tabela seria Locacaos (No ficou bom no hem!). Portanto para evitar tais
problemas, o ideal termos o controle sobre o nome das nossas tabelas.

O segundo ajuste consiste em impedir que o sistema gere a tabela EdmMetadata, que para
o nosso exemplo no ter utilidade.

Pronto, o nosso contexto esta pronto para o primeiro contato com o banco de dados. Se
voc ficou um pouco confuso, abaixo segue o cdigo da classe Contexto.

using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Data.Entity.ModelConfiguration.Conventions;

namespace ExemploEF.Inicio
{
public class Contexto : DbContext
{
public DbSet<Filme> Filmes { get; set; }

public Contexto()
{
Database.Connection.ConnectionString =
@"data source=fabio-pc\sql2008;
initial catalog=ExemploEF;
Integrated Security=SSPI";
}

protected override void OnModelCreating(DbModelBuilder


modelBuilder)
{

modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

modelBuilder.Conventions.Remove<IncludeMetadataConvention>();
}
}
}

Pem logo essa coisa pra funcionar!

Sim, sim, sim! Vamos escrever o cdigo para que isso acontea.

Abra a sua classe Program (Console Application), e vamos escrever um mtodo que vai
ser responsvel por criar o nosso banco. Como apenas uma aplicao de exemplo, no
vou escrever tratamentos de exceo. (Jamais deixe de fazer os tratamentos na sua
aplicao, isso muito importante)

O nosso mtodo vai verificar se existe algum banco gerado, se houver vamos deletar e
criar um novo. Segue abaixo.

namespace ExemploEF.Inicio
{
class Program
{
private static Contexto contexto;

static void Main(string[] args)


{
contexto = new Contexto();

ResetarBancoDeDados();
}

public static void ResetarBancoDeDados()


{
if (contexto.Database.Exists())
contexto.Database.Delete();

contexto.Database.Create();
}
}
}

Compile o programa e cruze os dedos. Se aparecer alguma mensagem na tela, tente revisar
os passos anteriores. Caso no tenha ocorrido nenhuma exceo, vamos conferir se
realmente a mgica aconteceu. Abra ento o Management Studio e vejamos.
Que maravilha, o meu deu certo! Tenho o meu banco de dados ExemploEF e a minha
tabela Filme com suas respectivas colunas. Vamos conferir o script de criao da tabela.

CREATE TABLE [dbo].[Filme](


[Id] [int] IDENTITY(1,1) NOT NULL,
[Titulo] [nvarchar](128) NULL,
[PrecoDeLocacao] [decimal](18, 2) NOT NULL,
PRIMARY KEY CLUSTERED
(
[Id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF,
IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON,
ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

Interessante que o Entity Framework j sabia que a propriedade Id da classe Filme era
chave primria e que tambm era auto-incremento (danadinho ele hem!). Porm como
vocs podem notar, a minha coluna de ttulo ficou com 128 posies por padro. Como
eu sou chato, eu quero ter o controle da situao, e quero que o Entity Framework siga o
meu padro.

Como fao isso?

Simples, vamos utilizar Data Annotations (atributos que podem ser aplicados na classe
ou em seus membros (propriedades, mtodos, etc.)). No vou entrar em detalhes pois eles
so carinhas bem legais e merecem um post especial, qualquer dvida ou se pintar a
curiosidade, j sabem onde perguntar (Orculo).

Para utilizar Data Annotations, voc deve fazer uma referencia no projeto para a
biblioteca System.ComponentModel.DataAnnotations. (na aba .NET)

Vamos configurar ento a nossa classe Filme. Eu quero dizer para o Entity Framework
que a minha coluna Id chave primria e auto-incremento (no tem importncia se ele
j sabia disso). Tambm quero que ele saiba que a minha coluna Titulo pode ter no
mximo cinquenta caracteres.

using System.ComponentModel.DataAnnotations;

namespace ExemploEF.Inicio
{
public class Filme
{
[Key]
[DatabaseGenerated(DatabaseGeneratedOption.Identity)]
public int Id { get; set; }

[StringLength(50)]
public string Titulo { get; set; }

public decimal PrecoDeLocacao { get; set; }


}
}

Os Data Annotations so esses carinhas ai entre colchetes []. Compile o programa e


confira o resultado atravs do Management Studio.
Agora sim! Ficou do jeito que eu queria.

E agora? o que a gente faz?

Agora a gente (eu) vamos dormir, afinal de contas amanh um novo dia e temos que
cumprir com as obrigaes.

Conseguimos atingir o que foi proposto no final do post anterior: Conectar a aplicao ao
banco de dados, gerar a nossa primeira tabela e manipular algumas informaes
(utilizando Data Annotations).

Como j estraguei a surpresa l na parte de cima, na prximo post vamos criar o restante
das nossas classes de modelo, inserir informaes no banco de dados e dividir a nossa
aplicao em camadas.

Espero que tenham gostado do post, e que tenha ajudado de alguma forma.

At o prximo

Categorias:.NET, EntityFramework Tags:C#, CodeFirst, CodeOnly, Entity Framework

Entity Framework Code First Parte 1


09/04/2011 Fabio Alves Lopes 5 comentrios

Este vai ser o primeiro post de uma sries de posts onde vamos criar uma pequena
aplicao utilizando a tecnologia Entity Framework. Vamos utilizar o conceito de
CodeFirst, tambm conhecido por CodeOnly.

O que esse tal Entity Framework?

O Entity Framework um conjunto de tecnologias que permite o mapeamento das suas


tabelas de banco de dados em forma de objetos/classes.

Legal, e o que CodeFirst?

No primeiro contato com o Entity Framework, a modinha era criar os ADO.NET Entity
Data Models, tambm conhecidos como edmx. Eles continham uma representao do seu
modelo (tabelas do banco de dados) parecida com o tiozo DataSet. Eu achei tudo muito
bonito e interessante; imagine voc ter uma representao do seu modelo de banco de
dados em forma de classes no sistema e poder fazer consultas em cima das mesmas.

Porm na minha opinio cometia o mesmo pecado do tiozo: Era pesado e gerava um
cdigo muito extenso nos bastidores, cdigo no qual o programador no tinha controle.

O CodeFirst permite a utilizao do conceito de POCO, onde voc escreve


munhecalmente suas classes/modelos. Logo, utilizando esse conceito, no teremos
aquela representao grfica toda colorida do modelo, teremos somente as nossas classes.
Muita gente pode pensar que isso uma coisa ruim, porm no . Imagine que voc ter
uma aplicao muito mais leve, com um cdigo mais legvel e de fcil manuteno.

Outro ponto interessante o programador ter a capacidade de escrever os seus modelos


antes mesmo de ter uma modelo fsico no banco de dados. E o que eu achei mais
maravilhoso de bom!: criar o banco de dados a partir das classes.

Existem vrias outras coisas interessantes a respeito desse carinha aqui, porm a
inteno deste primeiro post dar uma breve explicao do conceito pra no ficar muito
vago.

Mos a obra

Para a implementao, vou listar as ferramentas que sero utilizadas inicialmente:

Visual Studio 2010 Ultimate

SQL Server 2008 Express

Entity Framework 4.1 RC (o download pode ser feito aqui)

Primeiros passos

Abra o Visual Studio (tima!)


Clique em File\New\Project.

Sero listados vrios tipos de projetos, porm nesse momento vamos criar uma soluo
em branco. Na parte esquerda, v at o menu Other Project Types e selecione o sub-menu
Visual Studio Solutions, ento finalmente selecione o tipo Blank Solution. Vamos dar um
nome para a nossa soluo e clicar em OK.

Eu sei que isso muito bsico, porm nesse primeiro post vou levar em considerao que
possa haver leitores que nunca tiveram contato com o Visual Studio. No prximo post
vou aumentar o nvel e no ficar enchendo tanta linguia. Segue abaixo a imagem para
dar uma facilitada.

Depois de termos clicado em OK, vamos adicionar um novo projeto a nossa soluo.
Clique em File\Add\New Project. Vamos adicionar uma Console Application.
Vamos utilizar inicialmente uma Console Application, somente para darmos os primeiros
passos e entendermos um pouquinho o que o Entity Framework. Nos posts futuros
iremos refatorar esse cdigo e dividir corretamente as nossas camadas, de modo a deixar
a brincadeira mais interessante.

Planejamento

Pois bem, j que temos o nosso primeiro projeto, vamos implementar a nossa primeira
classe de modelo. Vamos adotar que o tema do nosso projeto ser aquele clssico
Sistema para controle de locadora de filmes. Vale lembrar que o exemplo ser apenas
para ilustrar as funcionalidades da ferramenta, e no para atender uma locadora de
verdade.

Quando pensamos em locadora de filmes, qual a primeira coisa que vem a cabea?
Claro, filmes. Olha que lindo, acabamos de identificar a nossa primeira abstrao do
mundo real, uma classe que vai conter os dados relacionados a filme.

claro que quando estamos trabalhando em uma equipe de desenvolvimento real esse
tipo de coisa no pode acontecer, ou seja, o sistema no vai se moldando to parcialmente
atravs de pequenas concluses. preciso um estudo detalhado do modelo de negcio da
empresa/ramo, consequentemente criamos uma ideia geral ou algum documento, e a
partir dai inicia-se a implementao.

Como ns somos bonitos e nesse exato momento a inteno apenas ilustrar, vamos
utilizar o mtodo VLSF (vontade louca de sair fazendo).

Criando nossa primeira classe: Filme


Quais informaes um filme pode conter? Ttulo, gnero, ano de lanamento, durao,
autores, elenco, sinopse, preo de locao, etc. So inmeros os dados, porm para o
nosso primeiro exemplo, vamos levar em considerao que a nossa classe Filme vai
possuir apenas trs dados bsicos: ttulo do filme, preo de locao e o cdigo nico de
identificao, mais conhecido como id.

Dentro de uma classe, esses dados so chamados de propriedades/atributos. Devemos


ento definir o tipo de cada propriedade. Sabemos que o ttulo vai armazenar um texto
que vai conter o nome do filme, logo o tipo dessa propriedade vai ser string. O preo ser
um decimal e o id ser um dado do tipo inteiro.

J definimos as informaes necessrias para podermos implementar a nossa classe


Filme. Agora devemos incluir uma classe dentro do nosso projeto.

Para incluir uma classe, basta clicar em cima do nosso projeto ExemploEF.Inicio, boto
direito\Add\Class. Em seguida vai aparecer uma janela, vamos dar o nome Filme para a
classe, em seguida clique OK.

Legal, a nossa primeira classe j esta inserida no projeto. Agora vamos implementar as
suas propriedades.

A imagem abaixo mostra a nossa classe Filme devidamente implementada, e para aqueles
que no estiverem habituados com o Visual Studio 2010, servir como apoio para saber
se esto seguindo os procedimentos corretamente.
Pronto, agora j temos a nossa classe Filme implementada. Agora devemos implementar
a nossa classe de contexto.

Contexto?

Sim, isso mesmo. O contexto o carinha que contm a conexo com o banco de dados, e
atravs dele que toda a magica acontece. Todas as nossas classes/entidades vo fazer
parte desse contexto, e a partir dai, poderemos obter e manipular as informaes.

Teremos ento as nossas colees de entidades na memria e somente quando for a hora
de persistir essas informaes, que o banco de dados vai ser requerido.

Isso da a leve impresso dele ser um bicho de sete cabeas, porm mais simples do que
se pode imaginar. Quando eu digo simples, simples mesmo: Vamos herdar a classe
DbContext, contida na biblioteca do EntityFramework, ou seja, vamos utilizar algo que
j esta pronto. (Se voc ainda no baixou a biblioteca, voc pode baixar ela aqui).

Finalmente o Entity Framework deu as caras!

Depois de termos instalado a biblioteca, devemos fazer uma referencia da mesma em


nosso projeto. Para fazer essa referencia, clique com o boto direito do mouse sobre a
pastinha References do projeto. Em seguida selecione a opo Add Reference. Ser
exibida uma janela, voc deve selecionar a tab Browse. Agora temos que encontrar a
biblioteca do EntityFramework. A pasta de instalao padro, e fica dentro dos Arquivos
de Programas. No meu caso foi instalada em C:\Program Files (x86)\Microsoft
ADO.NET Entity Framework 4.1 RC\Binaries. (Windows 64 bits).

Basta selecionar o arquivo EntityFramework.dll e clicar em OK. Como eu sei que no


comeo esse tipo de tarefa pode ser meio complicada, vou ser bonzinho e apresentar uma
imagem para ajudar.
Pronto, agora j podemos implementar nossa classe de contexto. Adicione uma nova
classe no projeto e de a ela o nome de Contexto. Em seguida vamos adicionar um using
para o assembly System.Data.Entity. atravs disso que a nossa classe vai conseguir
acessar a biblioteca do EntityFramework.

Agora vamos fazer a nossa classe Contexto herdar as propriedades e os comportamentos


da classe DbContext.

No se preocupe se voc no entendeu nada do que eu disse acima, logo abaixo esta o
cdigo de como vai ficar a nossa classe Contexto.

using System.Data.Entity;

namespace ExemploEF.Inicio
{
public class Contexto : DbContext
{

}
}

Agora vamos fazer com que o contexto possa ter uma coleo de Filmes criando uma
propriedade do tipo DbSet. Vamos dar o nome de Filmes para esta propriedade.

using System.Data.Entity;
namespace ExemploEF.Inicio
{
public class Contexto : DbContext
{
public DbSet<Filme> Filmes { get; set; }
}
}

Pronto, j temos o nosso contexto, e ele j pode conter uma coleo de filmes.

Pem logo essa coisa pra funcionar!

No, no, no! Isso vai ser o assunto do prximo post.

Espero que tenham gostado desse passo a passo introdutrio. No post seguinte vamos
elevar um pouco o nvel, com menos teoria e mais ao.

Vamos fazer a nossa aplicao se conectar com o banco de dados e gerar a nossa primeira
tabela, a partir dai vamos manipular algumas informaes e escrever alguns cdigos bem
legais.

At mais