Vinicius Quaiato

Tecnologia e algo mais…

Fala galera, recebi algumas dúvidas por e-mail e vamos resolver aqui.
Vamos trabalhar com relações many-to-many utilizando POCO e o Entity Framework 4.0.
Para ver como trabalhar com POCO no EF4 veja este post aqui.

Vamos fazer um exemplo bem simples, trabalhando com produtos e lojas. Cada produto poderá estar em muitas lojas, e uma loja poderá conter muitos produtos.
Abaixo temos o desenho de nosso modelo inicial:

Modelo de Classes Entity Framework 4.0

Feito isso vamos criar uma associação entre nossas entidades, como pode ser visto abaixo:

Criando associação no modelo do EF 4.0

Definindo a Associacao Many-To_Many no EF 4.0

Feito isso basta salvarmos nosso modelo e gerar o banco de dados. Lembrando de desmarcar a opção de geração de código no modelo (veja aqui como fazer isso).

Nossas classes ficarão simples, como não poderia deixar de ser.
Abaixo vemos a classe Produto, que como pode-se notar não possui nenhuma dependência do entity Framework e nem conhece nada relacionado com banco de dados:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Produto
{
    public virtual int Id { get; set; }
    public virtual string Nome { get; set; }
    public virtual decimal ValorSugerido { get; set; }
    private IList<Loja> lojasOndeVende = new List<Loja>();
    public virtual IList<Loja> LojasOndeVende
    {
        get
        {
            return this.lojasOndeVende;
        }
        set
        {
            this.lojasOndeVende = value;
        }
    }
}

Abaixo temos a classe Loja:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Loja
{
    public virtual int Id { get; set; }
    public virtual string Nome { get; set; }
    public virtual string Cidade { get; set; }
    private IList<Produto> produtosQueVende = new List<Produto>();
    public virtual IList<Produto> ProdutosQueVende
    {
        get
        {
            return this.produtosQueVende;
        }
        set
        {
            this.produtosQueVende = value;
        }
    }
}}

E aqui temos nossa classe de contexto do Entity Framework, que também criamos, de forma bastante simples:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class EF4Context : ObjectContext
{
    public EF4Context()
        : base("name=ModeloManyToManyContainer", "ModeloManyToManyContainer") { }
 
    private IObjectSet<Produto> produtos;
    public IObjectSet<Produto> Produtos
    {
        get
        {
            if (produtos == null)
                produtos = CreateObjectSet<Produto>();
 
            return produtos;
        }
    }
 
    private IObjectSet<Loja> lojas;
    public IObjectSet<Loja> Lojas
    {
        get
        {
            if (lojas == null)
                lojas = CreateObjectSet<Loja>();
 
            return lojas;
        }
    }
}

E isto é tudo que precisamos. Já podemos trabalhar com nossas entidades de forma a terem a relação Many-to-Many feita e funcionando.
Criei uma aplicação console para demonstrar isso. O método abaixo faz algumas inserções no banco, e o resultado da consulta pode ser visto na imagem a seguir:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

private static void InserirNovosProdutosELojas()
{
    var contexto = new EF4Context();
 
    var produto = new Produto();
    produto.Nome = "Produto de Soja";
    produto.ValorSugerido = 10;
 
    var produto2 = new Produto();
    produto2.Nome = "Produto de tofu";
    produto2.ValorSugerido = 10;
 
    var loja = new Loja();
    loja.Nome = "Loja do Vinicius";
    loja.Cidade = "São Paulo";
    loja.ProdutosQueVende.Add(produto);
 
    var loja2 = new Loja();
    loja2.Nome = "Loja Vegetariana";
    loja2.Cidade = "São Paulo";
    loja2.ProdutosQueVende.Add(produto);
    loja2.ProdutosQueVende.Add(produto2);
 
    contexto.AddObject("Produtos", produto);
    contexto.AddObject("Produtos", produto2);
    contexto.AddObject("Lojas", loja);
    contexto.AddObject("Lojas", loja2);
 
    contexto.SaveChanges();
 
    Console.ReadKey();
}

Reparem que apenas adicionamos os produtos nas lojas, e não precisamos adicionar as lojas aos produtos também. O Entity Framework é esperto para fazer essa associação.

Aqui podemos ver uma saída gráfica das nossas relações:

Resultado da relação Many-to-Many

Bom pessoal, éisso aê. A relação Many-to-Many com POCOs no Entity Framework 4.0 é bastante simples e natural. Não requer passos adicionais e nem complicados.

Qualquer dúvida, crítica ou sugestão, deixem seus comentários ou podem escrever email.

Att,
Vinicius Quaiato.

Fala galera, de buenas? Resolvi escrever um pouco sobre o Entity Framework 4.0 (na verdade é a versão 2 do EF mas para acompanhar o .NET 4.0 ele será chamado assim também).

Hoje vou mostrar uma característica bem interessante, que é o model first trabalhando com POCOs.
Model First diz respeito a primeiro criar suas entidades, ou seja, suas classes, e somente depois modelar o banco de dados – e é isto que queremos fazer quando desenvolvemos aplicações usando Orientação a Objetos, não é?
POCOs são classes simples, que não herdam nem implementam nenhuma outra classes/interface específica de frameworks, dizendo respeito exclusivamente ao nosso domínio e contendo apenas o necessário ao nosso domínio.

Para começar vamos criar um projeto de testes e adicionar um arquivo .edmx como mostra a figura abaixo:

Criando o arquivo edmx

Selecionando o empty model

Pronto!
Vamos então adicionar duas entidades ao nosso design surface. Estas serão nossas entidades POCO, ou seja, não terão nenhuma dependência do Entity Framework, nem do Linq, nem de nada, é apenas o nosso modelo de classes, vamos ainda desabilitar a geração de código do Visual Studio, para que ele não “polua” as classes:

edmx com 2 entidades

E então clicamos na parte branca do design e abrimos a janela de propriedades para desabilitar a geração de código:

desabilitando geração de código no EF 4.0

Estamos a meio caminho andado. Pode parecer muito trabalho a ser feito, mas isso não leva mais do que 2 minutos. É realmente simples e os resultados são muito bons.
Agora vamos para a parte bacana, codificar nossas classes.
Vamos iniciar codificando as classes Pedido e ItemPedido, que são classes realmente bastante simples:

public class Pedido
{
    public virtual int Id { get; set; }
    private IList<ItemPedido> itens = new List<ItemPedido>();
    public virtual IList<ItemPedido> Itens
    {
        get { return this.itens; }
        set { this.itens = value; }
    }
}
 
public class ItemPedido
{
    public virtual int Id { get; set; }
    public virtual string Produto { get; set; }
    public virtual int Quantidade { get; set; }
    public virtual Pedido Pedido { get; set; }
}

Os virtuais que usamos nas nossas classes são para que o Entity Framework possa fazer o “tracking” dos nossos objetos. Internamente ele criará proxies para nossas classes. Em um primeiro momento basta colocarmos as propriedades como virtual e ele se encarregará de tudo, isso ainda ajudará no Lazy Loading.

Agora, como desabilitamos a geração de código, precisamos também criar o nosso contexto do EF. Isso é bastante simples, e neste cenário nos obrigará a escrever apenas umas 10 linhas de código, como pode ser visto abaixo:

public class EF4Context : ObjectContext
{
    public EF4Context()
        : base("name=EF4Container", "EF4Container") { }
 
    private IObjectSet<Pedido> pedidos;
    public IObjectSet<Pedido> Pedidos
    {
        get
        {
            if (pedidos == null)
                pedidos = CreateObjectSet<Pedido>();
 
            return pedidos;
        }
    }
}

Feito isso nos resta apenas gerar o banco de dados. Como dissemos, geramos primeiro nossas classes, sem nos preocupar em como estes dados seriam armazenados, conseguimos focar puramente no nosso domínio e no nosso modelo, afinal estamos pensando em classes e objetos, e não em linhas/tuplas de banco, chaves, índices, etc.
O Visual Studio irá gerar o código necessário para nosso banco de dados veja abaixo:

gerar banco de dados usando o modelo do EF 4.0

Agora é só executar o SQL gerado:

executando SQL gerado pelo EF 4.0

Se vocês fizeram tudo certinho até o momento, devem ser capazes de executar os seguintes códigos de testes com sucesso:

[TestMethod]
public void Deve_Adicionar_Um_Pedido_No_DB_Usando_Contexto_E_Poco()
{
    var contexto = new EF4Context();
 
    var pedido = new Pedido();
 
    pedido.Itens.Add(new ItemPedido
    {
        Produto = "Novo Produto",
        Quantidade = 5,
        Pedido = pedido
    });
 
    contexto.AddObject("PedidoSet", pedido);
    contexto.SaveChanges();
}

Depois este:

[TestMethod]
public void Deve_Obter_Todos_Os_Pedidos_Do_Banco_Usando_Contexto_E_Pocos()
{
    var contexto = new EF4Context();
 
    var pedidos = contexto.Pedidos.ToList();
 
    Assert.IsTrue(pedidos.Count > 0);
}

E por fim este:

1
2
3
4
5
6
7
8
9
10
11
12
13

[TestMethod]
public void Deve_Selecionar_1_Pedido_Do_Banco_Usando_Contexto_E_Pocos()
{
    var contexto = new EF4Context();
    contexto.ContextOptions.LazyLoadingEnabled = true;
 
    var pedido = contexto.Pedidos
                            .Where(p => p.Id == 1).Single();
 
    Assert.AreEqual(1, pedido.Id);
    Assert.IsTrue(pedido.Itens.Count > 0);
    Assert.AreEqual("Novo Produto", pedido.Itens[0].Produto);
}

Percebam como na linha 5 habilitamos o lazy loading para que as propriedades sejam carregadas no momento em que forem chamadas apenas.

E se fizermos uma consulta no banco de dados, veremos que de fato os dados estão lá:

dados armazenados no banco pelo EF 4.0 usando Pocos

Bom pessoal, é isso.
Esta é uma das funcionalidades presentes no Entity Framework 4.0. É claro que existe muita coisa a ser explorada ainda, e existem muitas coisas a serem feitas ainda, mas é um enorme avanço poder trabalhar com POCOs e utilizar os recursos de uma ferrmenta ORM como o EF. Poder dar “tchau” para os SqlConnection, SqlCommand, ExecuteScalar, etc, é algo realmente incrível.

Espero que tenham gostado. Dúvidas, críticas e sugestões me enviem email ou comentários.

Abraços,
Vinicius Quaiato.