Início > Ado.Net > Série EF : Utilizando POCO separação das entidades do Contexto (Parte 2)

Série EF : Utilizando POCO separação das entidades do Contexto (Parte 2)

22 de agosto de 2011 Deixe um comentário Go to comments

Continuando nossa série de artigos, confira aqui parte inicial

Introdução

O que é POCO?
POCO é o acrônimo de Plain Old CLR Object, e esta “técnica” se deriva do POJO, ambas permitem que você escreva sua própria classe de entidade de forma ignorante a persistência de dados, ou seja, você cria sua classe sem nenhuma herança ou implementação de contrato de dados (objetos chamados de estrutura simples), e esta classe é utilizada em ferramentas ORM para persistir os dados em um repositório.

Em resumo o que iremos fazer neste exemplo é criar um projeto chamado entidades, onde este irá conter todas nossas classes de entidades (PESSOA e PROFESSOR) e em outro projeto vamos criar a infra para persistência usando uma ferramenta ORM (Entity Framework), ela receberá as nossas entidades e persistir em um banco de dados SQL Server. A ideia do artigo é mostrar como é simples usar o POCO para separar fisicamente as funcionalidades da solução.

Criando a Solução

Para nosso exemplo utilizaremos uma solução do Visual Studio contendo três projetos, sendo eles:

Nome Tipo projeto Descrição
NBSampleEF Console Application Projeto Front-End.
NBSampleEF.DAL Class Library Projeto que irá conter o ObjectContext, responsável por persistir os objetos no banco de dados.
NBSampleEF.Entities Class Library Projeto que irá conter as entidades de nossa solução.

Criando as entidades

Abra o projeto NBSampleEF.Entities e crie duas classes para representar nossas entidades, importante que quando usamos o POCO temos algumas restrições, veja algumas delas:

  • O Nome da classe precisa ser o mesmo nome da entidade no EDM.
  • O Nome e os tipos das propriedades da classe precisam ser iguais aos da entidade no EDM.

Abaixo o código das classes de entidades:

Entidade ALUNO

namespace NBSampleEF.Entities
{
    publicclassAluno
    {
        publicint Id { get; set; }
        publicstring Nome { get; set; }
        publicint IdProfessor { get; set; }
        publicProfessor Professor { get; set; }
    }
}

Entidade PROFESSOR

using System.Collections.Generic;
namespace NBSampleEF.Entities
{
    publicclassProfessor
    {
        publicint Id { get; set; }
        publicstring Nome { get; set; }
        publicList<Aluno> Aluno { get; set; }
    }
}

 

Criando a estrutura de persistência de dados

No projeto NBSampleEF.DAL referencie o projeto de entidades através do Add-> References -> NBSample.Entities, posteriormente crie um arquivo do tipo Entity Data Model (.edmx) apontando para seu banco de dados, de o nome do .edmx como ArtigosEFSample. Seu projeto deverá ficar conforme a imagem abaixo:

2 overviewEFDALproject

 

Nota: Se você expandir o arquivo .edmx, irá ver que existe um arquivo abaixo dele chamado ArtigosEFSample.Designer.cs este arquivo contem as classes do ObjectContext e as classes de entidades mapeadas.

 

No solution explorer clique com o botão direito ArtigosEFSample.edmx e escolha a opção propriedades (F4). Na tela de propriedades limpe o conteúdo do Custom Tool (propriedade responsável por gerar os códigos automaticamente). Compile a aplicação e verá que nenhum arquivo de designer do ArtigosEFSample.edmx será gerado.

Com isso definimos a estrutura de acesso a dados sem gerar as entidades automaticamente, no entanto, agora se faz necessário criarmos uma classe de persistência de dados, para isso, crie uma nova classe chamada ArtigoObjectContext . Herde a ArtigoObjectContext da classe ObjectContext e modifique o construtor Default, conforme exemplo abaixo:

using System.Data.Objects;
namespace NBSampleEF.DAL
{
    classArtigoObjectContext : ObjectContext
    {
        public ArtigoObjectContext()
            : base(“name=ArtigoEFBlogEntities”, ArtigoEFBlogEntities”)  {        }

    }

}

 

Nota: Note que estamos herdando no construtor default o construtor da classe base, e neste passamos a connectionstring chamada artigoEFBlogEntities que se encontra no arquivo app.config. Este arquivo foi criado junto com a parametrização do Modelo.

 

Agora iremos criar nossos ObjectSet para efetuar as operações de CRUD nas entidades, para isso crie duas propriedades, sendo uma para cada entidade. E inicie ambas no construtor default da classe (criado anteriormente) através do método “base” CreateObjectSet.

using System.Data.Objects;
using NBSampleEF.Entities;

namespace NBSampleEF.DAL
{
    publicclassArtigoObjectContext : ObjectContext
    {
        public ArtigoObjectContext()

            : base(“name=ArtigoEFBlogEntities”, “ArtigoEFBlogEntities”)
        {
            alunos = CreateObjectSet<Aluno>();
            professores = CreateObjectSet<Professor();
        }
        publicObjectSet<Aluno> Alunos
        {
            get
            {
                return alunos;
            }
        }
privateObjectSet<Aluno> alunos;
publicObjectSet<Professor> Professores
        {
            get
            {
                return professores;
            }
        }
        privateObjectSet<Professor> professores;
    }
}

Nota: O ObjectSet<T> é uma especialização do ObjectQuery<T> que foi introduzido no EF 4.0

 

Persistindo as entidades no repositório

No projeto NBSampleEF referencie o projeto de entidades através do Add-> References -> NBSample.Entities faça o mesmo para o projeto de acesso a dados, use o Add ->References -> NBSample.DAL, posteriormente copie a connectionstring do arquivo app.config (NBSample.DAL ) para dentro do arquivo de configuração do projeto NBSampleEF, o arquivo app.config do NBSampleEF deverá ficar conforme abaixo:

<?xmlversion=1.0encoding=utf-8?>
<configuration>
  <connectionStrings>
    <addname=ArtigoEFBlogEntitiesconnectionString=metadata=res://*/ArtigosEFSample.csdl|res://*/ArtigosEFSample.ssdl|res://*/ArtigosEFSample.msl;provider=System.Data.SqlClient;provider connection string=&quot;Data Source=.\sqlexpress;Initial Catalog=ArtigoEFBlog;Integrated Security=True;Pooling=False;MultipleActiveResultSets=True&quot;providerName=System.Data.EntityClient />
</
connectionStrings>
</configuration>

 

Agora para efetuar os nossos testes, dentro do método Main (método de entrada da aplicação) iremos inserir o código para criar um aluno e um professor e persistir na base de dados e posteriormente iremos pesquisar o mesmo, veja abaixo:

staticvoid Main(string[] args)
        {

            NBSampleEF.DAL.ArtigoObjectContext context = new DAL.ArtigoObjectContext();

            using (context)
            {
                //Criando um novo objeto do tipo professor.
NBSampleEF.Entities.Professor novoProfessor = new Entities.Professor();
                novoProfessor.Id = 1;
                novoProfessor.Nome = “Michel Habber”;
                //Inserindo o objeto professor no repositorio.
                context.Professores.AddObject(novoProfessor);
                context.SaveChanges();

//Criando um novo objeto do tipo aluno.
                NBSampleEF.Entities.Aluno novoAluno = new Entities.Aluno();
                novoAluno.Id = 1;
                novoAluno.Nome = “Joaozinho”;

                novoAluno.Professor = novoProfessor

//Inserindo o objeto aluno no repositorio.
                context.Alunos.AddObject(novoAluno);
                context.SaveChanges(); 

                //Pesquisando as entidades.
                var query = from entity in context.Alunos
                            where entity.Id >= 1
                            select entity;

                foreach (var entity in query)
                {
                    Console.WriteLine(“Id: {0}, Nome: {1}”, entity.Id, entity.Nome);
                }
                Console.Read();
            }
        }

 

Execute o programa, na tela de console deverá aparecer o seguinte resultado:

3 prompt

 

 

Com o poco é possível ter seu modelo de entidade e automatizar o CRUD usando o ObjectContext, é importante saber que também existem outras soluções quando falamos de separação física de entidades e repositórios.

Aguarde o proximo post.. tem mais.

 

[]´s

Nelson Borges
**Ao infinito e além **

Categorias:Ado.Net
  1. Tiago Cipriani
    12 de março de 2012 às 16:28

    Muito bom o post, grande trabalho…
    Mas gostaria de ver a continuação, se possível continue a série de post sobre EF.

    Muito Obrigado.

  1. No trackbacks yet.

Deixe uma resposta

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: