EntityTypeConfiguration

12/03/201208/04/2012 Fernando H. I. B. Ferreira6 Comentários

Quando utilizamos a Fluent API para configuração do mapeamento de nosso banco de dados, corremos o risco de tornar o método OnModelCreating muito extenso e complexo.

Para evitar este cenário podemos criar uma classe que herde de EntityTypeConfiguration e que descreva qual a configuração de nosso mapeamento.

A classe EntityTypeConfiguration permite o mapeamento indvidual de nossas entidades, tornamos o comportamento de nosso método OnModelCreating mais simples e encapsulando o mapeamento de nossas entidades em classes próprias para isso.Leia mais »

EF41 – Inicializadores de Banco de Dados

12/01/201208/04/2012 Fernando H. I. B. Ferreira2 Comentários

Ao trabalharmos com o Entity Framework Code First nos deparamos com diversas convenções. Uma das mais importantes é processo de construção do banco de dados. O Entity Framework 4.1 nos fornece nativamente três inicializadores de banco de dados, sendo eles:

DropCreateDatabaseIfModelChanges:apaga e recria o banco de dados toda vez que alguma alteração no modelo de classes for identificada. Observação: se a tabela EdmMetadata não estiver sendo criada no banco de dados (através da remoção da convention IncludeMetadataConvention), então está opção não irá funcionar e irá disparar uma Exception do tipo NotSupportedException.

CreateDatabaseIfNotExists:cria o banco de dados se o mesmo não existir, se o modelo de classes sofrer alguma alteração será disparada uma exception.

DropCreateDatabaseAlways:apaga e recria o banco de dados sempre, mesmo que nenhuma alteração no modelo de classes tenha sido feita.Leia mais »

Construindo sua camada de acesso a dados com o Entity Framework 4.1

26/11/201126/11/2011 Fernando H. I. B. Ferreira3 Comentários

O Entity Framework 4.1(EF41) Code First veio para ajudar os desenvolvedores no processo de construção da camada de acesso a dados de suas aplicações. Ao contrário dos demais modelos do Entity Framework, o modelo Code First tem por objetivo criar o banco de dados seguindo como base a estrutura de nossas classes – os demais modelos, conhecidos como Table First, baseavam a criação das classes no modelo existente em nosso banco de dados. A vantagem da utilização do Code First é a possibilidade de criar um modelo de classes muito mais próximo a nossa necessidade, ao contrário das abordagens anteriores que produziam um modelo de classe “adaptado” de nossa estrutura de banco de dados.

Neste exemplo vamos discutir os modos de implementação de diferentes modelos de relacionamentos (e.g. um-para-muito, muitos-para-muitos, um-para-um) utilizando o ADO.Net Entity Framework 4.1. Além disso, quero mostrar algumas novas features e dar algumas dicas de como nos adequar ao Entity Framework 4.1.

Vamos começar! Alegre

Obs.: Para fazer download do código-fonte acesse este link: http://code.msdn.microsoft.com/Construindo-sua-camada-de-de659425.

1 – Nosso projeto de teste

Para este teste criaremos um cadastro de Clientes, Fabricantes, Produtos e Ordens de Compra. Neste modelo um cliente pode efetuar diversas ordens de compras, sendo que cada comprar pode conter um ou mais produtos, onde cada produto pode estar atrelado a uma ou mais ordens de compra. Além disso, um produto obrigatoriamente contém um fabricante. Nosso diagrama de classes será o seguinte:

2 – Camadas da aplicação

Para este exemplo adotei os design patterns MVC e DAO. Os projetos estão dispostos como a imagem a seguir:

Commerce.Controler: corresponde a camada de controle de nossa aplicação.

Commerce.Entity: possui todas as entidades lógicas de nossa aplicação, além das interfaces que devem ser implementadas pelas demais camadas.

Commerce.Data: responsável pela funcionalidade de armazenamento das informações, esta camada engloba todo o uso do Entity Framework 4.1, diminuindo a dependência do projeto a um tecnologia. Isso permite a fácil manutenção e alteração da tecnologia, sem gerar impactos globais por toda a aplicação.

Commerce.Console: camada de apresentação e consumo dos recursos.

3 – Estratégia de criação da base de dados

Para definir a estratégia de criação do banco de dados fazemos uso de inicializadores.A estratégia default é a DropCreateDatabaseIfModelChanges, que apaga o banco de dados e o recria, além dessa estratégia ainda existem outras duas, sendo elas: DropCreateDatabaseAlways e CreateDatabaseIfNotExists. O time de produto do ADO.Net trabalha hoje em um projeto chamado Code First Migration, que trata do processo de adequação do modelo do banco de dados com as atualizações de suas entidades, sem que seja necessário apagar e recriar o banco de dados. Para fazer uso dos inicializadores de bancos de dados crie em seu DataContext um construtor que defina a estratégia de criação da base de dados como a seguir:

4 – Remoção de convenções do Entity Framework 4.1

Para efetuar o mapeamento automático de nossas tabelas, o EF41 adota algumas convenções de nomenclatura, tipos de dados, e outros recursos. Para adicionar ou remover convenções devemos sobrescrever o método OnModelCreating de nosso DataContext. Em nosso exemplo removerei duas convenções: IncludeMetadataConvention, que evita a criação da tabela EdmMetada, que é uma tabela que contém um código uma única linha com um código hash utiliza para verificar se o modelo de nosso código é o mesmo do modelo de nosso banco de dados (mais informações aqui: http://blog.oneunicorn.com/2011/04/08/code-first-what-is-that-edmmetadata-table/); e PluralizingTableNameConvention, que é um atributo que evita que a nome das tabelas seja pluralizado, isto é, se você possui uma entidade chamada Carro, a tabela criada automaticamente no banco de dados se chamará Carro, e não Carros como a convenção do EF41 faz.

5 – Tipos complexos

É bastante comum em nossas aplicações a necessidade de utilizarmos atributos que apenas servem como “agrupadores” de dados, e que na verdade não deve ser mapeamos em uma única tabela dedicada a eles. Podemos adotar como exemplo um tipo de dados Endereço. Uma classe chamada Endereço é bastante importante para agrupar informações de localidade, mas não possui características que exijam mapeamento para uma tabela dedicada exclusivamente para isso. Diante deste cenário devemos fazer uso do atributo ComplexType. Este atributo quando utilizado indica que nossa classe é um tipo complexo, que não deverá ser persistido em uma tabela própria, e que estará vinculado a atributo de alguma classe. Podemos indicar que uma classe é um tipo complexo de duas maneiras, sendo elas:

2.1 – No corpo da classe, indicando através do atributo ComplexType:

2.2 – Indicando o tipo complexo em nosso DataContext, dentro do método OnModelCreating:

Ultimamente tenho pensado que é mais interessante configurar o mapeamento de nossas classes dentro do DataContext do que em nossas classes através da utilização de atributos. Acredito que essa é a melhor forma, pois nosso projeto de entidades ficará livre de mais dependências, necessitando apenas de recursos nativos do Framework .

6 – Entidade base para persistência de dados em fontes de dados

É interessante, ao implementarmos nossas entidades, a criação de uma entidade base que defina atributos obrigatórios para todas as entidades. Neste exemplo criei uma entidade chamada DataEntity que contém três atributos: Id, atributo do tipo inteiro que servirá como chave primária de nossas entidades na base de dados; GlobalId, atributo do tipo GUID que fornecerá um identificador global a nossos registros dentro da base de dados; e Created, atributo do tipo DateTime que informará a data de criação de nossas entidades.

A utilização dessa classe como entidade base exige duas implementações em nossas entidades:

1 – Herança

2 – Invoque ao construtor da classe base em nossas entidades

7 – Interface como contrato para os repositórios

Para implementação dos repositórios criei uma interface com um conjunto de métodos obrigatórios que se espera de um repositório.

Nessa interface temos as assinaturas:

void Save(T target): este método deve ser responsável pela inclusão e atualização dos dados na base de dados. Uma vez executado deve garantir que os dados serão inclusos ou atualizados conforme a entidade passada por parâmetro.

void Delete(T target): método de exclusão de registros da base de dados. Quando invocado, deve apagar o registro passado por parâmetro da base de dados.

T GetById(int id): método que deve retornar o registro na base de dados que contiver em sua chave primária o valor passado por parâmetro.

T GetByGlobalId(Guid id): gosto bastante de utilizar um campo UNIQUEIDENTIFIER em meus registros, pois atribuímos ao registro uma chave de identificação única que o torna único em todo o banco de dados, independente de sua localização – assim como propostos em bases de dados orientadas a objetos.

IEnumerable<T> GetAll(): deve retornar todos os registros existentes na base de dados para a entidade consultada.

IEnumerable<T> ExecuteQuery(Func<T, bool> expression): este método faz consultas na base de dados utilizando como filtro a expressão passada por parâmetro.

Esta interface define o que é esperado por cada classe repositório, mas se notarmos ela utiliza um tipo genérico como parâmetro para sua implementação. Para refinarmos o seu uso e tornarmos nosso repositório reutilizável e expansível, acredito que devemos criar para cada classe repositório uma interface que implemente o contrato definido por IRepository<T>, mas que defina qual entidade será persistida ali. Tomemos como exemplo a interface do repositório de clientes, conforme código:

Seu classe repositório deve implementar ICLientRepository e ser igual a seguinte implementação:

Observem que nossa classe de repositório implementa a interface IClientRepository utilizando a entidade Client como alvo de nossas ações de persistência no banco de dados, e não um tipo de dados genérico, como utilizado na interface IRepository<T>.

Este uso é indicado ao construirmos nossos testes unitários, pois ao implementarmos nossos repositórios fakes já teremos nossos repositórios bem estruturados e prontos para extensão.

Outra dica para a construção de nossos testes unitários é tornar os repositórios parametrizáveis através de nossas classes controllers. Devemos criar uma assinatura de construtor que permita a parametrização do repositório que utilizaremos em nossa implementação, assim como é importante fornecer um construtor que defina um repositório padrão, caso não seja passado nenhum parâmetro para o repositório, podemos fazer isso desta forma:

Bom, espero que algumas dicas aqui descritas ajudem a implementação de suas aplicações com o Entity Framework 4.1. Bom estudo e continuem programando… Alegre

[]s!

Por
Fernando Henrique Inocêncio Borba Ferreira

Entity Framework 4.1 – Armazenamento de arquivos

04/11/201104/11/2011 Fernando H. I. B. FerreiraDeixe um comentário

No Entity Framework 4.1 o armazenamento de dados binários no banco de dados é mais simples. Antes, no LINQ to SQL, era preciso criar uma instância da classe System.Data.Linq.Binary, valorizá-la com os dados binários e atribuí-la a sua propriedade correspondente em nossa entidade. Agora este cenário é mais simples, pois para persistir dados binários é apenas preciso criar uma propriedade do tipo byte[] (byte array) e lhe atribuir os dados diretamente.

Nesta demonstração iremos armazenar dados de qualquer arquivo selecionado, através de uma caixa de dialogo, no banco de dados. Iremos armazenar em nossa tabela: nome do arquivo, caminho, extensão, um valor para checksum e sua representação em binários.

Um checksum (ou hash sum) é uma sequência de dados de tamanho fixo, calculada a partir de um conjunto de dados binários. É um conceito bastante utilizado em tarefas de armazenamento e transmissão de dados. Seu funcionamento se dá pela seguinte forma: 1 – Calcula-se o checksum; 2 – Executa-se o armazenamento ou a transmissão dos dados; 3 – Calculsa-se o checksum dos dados recebidos; 4 – Verifica-se se o checksum calculado antes do armazenamento/envio é o mesmo da recepção, se sim, então os dados trafegaram com sucesso, se não, ocorreu algum desvio ou perda de dados durante o tráfego.

Para o cálculo do checksum utilizamos o algoritmo MD5, existem outros algoritmos de Hash que são mais seguros e produzem sequências maiores (i.e SHA1, SHA256, SHA512). Mas para este exemplo o MD5 é suficiente.

Abaixo o algoritmo utilizado para gravação dos dados binários no banco de dados, além do checksum:

Aqui estão os códigos da classe Arquivo (a entidade que será persistida no banco de dados), a classe ContextoDados (classe que herda de DbContext e faz o papel de proxy para nossas requisições com o banco de dados), e a classe Config (que é responsável por acessar configurações de nossa aplicação, como por exemplo a string de conexão).

Detalhe importante, para a coluna que irá conter os dados binários, o Entity Framework 4.1 criou na tabela uma coluna do tipo varbinary(max).

Para fazer download do exemplo acessem http://code.msdn.microsoft.com/Entity-Framework-41-6a79eb9e

[]s e até o próximo!

Por
Fernando Henrique Inocêncio Borba Ferreira.

Entity Framework 4.1 – Validations

03/11/2011 Fernando H. I. B. Ferreira2 Comentários

O Entity Framework 4.1 fornece uma grande variedade de ferramentas para validação de dados. Neste exemplo vamos apresentar algumas das técnicas que podemos encontrar dentro do EF 4.1.

Data Annotations

Data Annotations são atributos, contidos no namespace System.ComponentModel.DataAnnotations, que quando adicionados em nossas classes fornecem características a nossos atributos e as suas respectivas colunas no banco de dados. Alguns desses atributos possuem caráter de validação, como: Required, exige que o campo seja preenchido; MaxLength, limita o tamanho do campo a uma quantidade máxima de caracteres; e MinLength, indica a quantidade mínima de caracteres.

Ao tentar salvar os dados na base de dados se algumas das restrições não estiverem sendo atendidas exceptions serão lançadas.

Fluent API Validations

O uso de Fluent API substitui o uso de Data Annotations e resulta no mesmo funcionamento. Ao contrário dos Data Annotations, as restrições não são inclusas na entidade, elas são inclusas no método OnModelCreating da classe de contexto com o banco de dados.

IValidatableObject

Para validações mais complexas que exijam alguma lógica ou verificação dentro de um contexto, a interface IValidatableObject, contida no namespace System.ComponentModel.DataAnnotations, fornece o método Validate que é invocado durante o comando SaveChanges, ou que pode ser chamado a qualquer momento que quisermos validar o conteúdo de nossa classe.

O método Validate retorna uma coleção de ValidationResults. Cada ValidationResult deve representar a validação efetuada, indicando a mensagem de erro e as propriedades que estão associadas com a validação.

Executando validações prévias

Para execução de validações prévias, antes de executar o comando SaveChanges, é possível executar o método GetValidationErrors, presente no contexto com o banco de dados. Esse método retorna uma coleção de erros encontrados durante a validação das entidades adicionadas no contexto. O exemplo abaixo ilustra sua utilização.

Captura de exceções geradas por validações

Sempre que uma validação encontrar um erro dentro do domínio de entrada, uma exception do tipo DbEntityValidationException será disparada. Para receptar essas exceções e fazer o tratamento necessário, faça desta maneira:

Como pudemos ver, validações complexas devem ser tratadas pelo uso da interface IValidatableObject, enquanto que restrições de entrada (i.e. valores nulos, valores em branco, valores fora do tamanho esperado) deve utilizar Fluent API Validations ou Data Annotations. Entre o uso de Fluent API Validations ou Data Annotations, fico pelo uso de Data Annotations, pois utiliza uma sintaxe mais simples, mais fácil de ser escrita, mais fácil de ser entendida e segue um padrão sintático mais próximo ao das demais DataAnnotations.

Para fazer download do exemplo, acesse: http://code.msdn.microsoft.com/Entity-Framework-41-a701026d

Por
Fernando Henrique Inocêncio Borba Ferreira.

Entity Framework – Data Annotations

28/10/201103/11/2011 Fernando H. I. B. Ferreira12 Comentários

O Entity Framework (EF) permite que utilizemos nossas classes para construção e mapeamento de nosso banco de dados, para tanto algumas convenções são necessárias para que ocorra o mapeamento. Mas muitas vezes as convenções não são suficientes, pois em determinados cenários a representação de nossas classes não é a mesma representação de nosso banco de dados. Este post objetiva apresentar o uso de DataAnnotations (atributos de mapeamento) presentes no namespace System.ComponentModel.DataAnnotations para construção de nossas classes. Abaixo seguem alguns dos atributos mais utilizados, seu modo de uso e seu impacto no banco de dados.

Key
As entidades mapeadas pelo Entity Framework precisam de uma propriedade que trabalhe como chave primária (propriedade chave), que trabalhe como “propriedade de rastreamento” do dado dentro da tabela, contendo um valor que diferencie o registro dos demais ali armazenados. Por convenção, o EF procura em sua classe por uma propriedade nomeada como “Id” ou uma propriedade nomeada com o nome da classe concatenada a palavra “Id” (i.e. ProdutoId, PedidoId, ClienteId). Caso o EF não encontre uma propriedade que esteja dentro de suas convenções, então uma exception será disparada exigindo que a classe possua uma propriedade chave. Caso sua classe não possua uma propriedade cujo nome esteja dentro destas convenções então é possível utilizar o atributo Key para indicar qual propriedade de sua classe deverá funcionar como propriedade chave.

Impacto no banco de dados: será gerada uma primary key com identação automática (identity).

Required
O atributo Required indica que um atributo em particular é obrigatório e que não poderá deixar de ser valorizado.

Impacto no banco de dados: o uso deste atributo adiciona uma restrição “not null” na coluna gerada no banco de dados.

MaxLength e MinLength
Estes atributos validam o tamanho do dado inserido, limitando o tamanho máximo e/ou indicando seu tamanho mínimo.

Impacto no banco de dados: o tamanho das colunas criadas no banco de dados serão limitados pelo uso do atributo MaxLenght. O tamanho default das colunas, sem o uso do atributo MaxLenght, é de 128 caracteres.

NotMapped
Existem cenários onde nem todos os atributos de nossas classes devem ser mapeados para o banco de dados. Este cenário existe quando alguma das propriedades de nossa classe é resultante de alguma ação dinâmica ou cálculo, e que não precisa ser armazenada na base de dados.

Impacto no banco de dados: nenhum, esse atributo não acarreta na criação de nenhuma coluna, na verdade ele é ideal para que a coluna não seja criada.

ComplexType
Não é incomum que nossa classes possuam propriedade que sejam instâncias de outros objetos, cujos dados não queremos armazenar em tabelas dedicadas. No nosso exemplo podemos incluir uma propriedade que indique qual o endereço de entrega de um malote, mas talvez não seja necessário possuir uma tabela exclusiva para o armazenamento dos endereços, podemos desejar que nossa tabela de malote possuísse as colunas de endereço dentre suas colunas. Para tanto, devemos utilizar o atributo ComplexType para indicar este cenário. Detalhe, este atributo deve ser incluído na classe que corresponde ao tipo complexo, não na classe que contém o atributo com o tipo complexo.

Impacto no banco de dados: nenhuma nova tabela será criada, em contraponto, as propriedades existentes na classe que contém o atributo ComplexType serão mapeadas para a tabela que contém a propriedade que utiliza o tipo de dados.

Table and Column
Podem existir dois casos onde os nomes das colunas das tabelas não são os mesmos dos nomes dos atributos das classes, sendo: o primeiro, quando o banco de dados já existe e é preciso criar o mapeamento para o mesmo; segundo, quando por alguma necessidade do cliente o banco de dados deve possuir uma nomenclatura de acordo com um conjunto de regras e padrões.

O atributo Table permite o mapeamento de uma classe para uma tabela, substituindo as conversões do Entity Framework.

O atributo Column permite a definição do nome da coluna que será mapeada pelo Entity Framework. No exemplo abaixo é possível notar que também é possível a combinação de diferentes atributos de mapeamento em uma única propriedade.

ForeignKey
O atributo ForeignKey indica qual propriedade na classe representa o campo que corresponde à chave estrangeira entre as tabelas. Note que no exemplo abaixo o atributo ForeignKey está acima da propriedade que representa a navegação entre as duas entidades.

Por
Fernando Henrique Inocêncio Borba Ferreira.

Entity Framework 4.1 + MVC + DAO

25/10/201103/11/2011 Fernando H. I. B. FerreiraDeixe um comentário

Neste exemplo vamos demonstrar o uso dos design patterns MVC e DAO, combinados com a utilização do Entity Framework 4.1 como tecnologia de acesso a dados de nossa aplicação.

O MVC (Model-View-Controller) é um design pattern bastante utilizado no mercado devido a sua capacidade de dividir a aplicação em camadas especialistas em suas funções, favorecendo a alta coesão das mesmas. A camada model é responsável por representar o mundo real através do uso de objetos. A camada view é dedicada exclusivamente a apresentação dos dados, podendo ser uma aplicação web, uma aplicação console, um formulário do Windows, uma page Silverlight, ou qualquer outra tecnologia front-end. A camada controller faz ponte entre a camada view e a camada model, interceptando a comunicação entre as duas e aplicando regras, validações, redirecionamentos ou encapsulando a comunicação com diferentes frameworks e sistemas. Outra vantagem deste modelo é a possibilidade de criar módulos independentes que trabalhem de modo desacoplado, para que se tornem fáceis de serem substituídos e reutilizados.

O design pattern DAO (Data Access Object) tem o objetivo de encapsular todos os acessos as fontes de dados feitas na aplicação. O uso deste design pattern permite que nossa aplicação não fique dependente de uma tecnologia de acesso a dados, pois estaremos agrupando todas as regras e usos de frameworks específicos de acesso a dados em uma única camada que pode ser facilmente substituída. Caso seja necessária a substituição da tecnologia de armazenamento (exemplo: de MS SQL para Oracle, ou de MS SQL para SQL Azure, ou de Oracle para alguma tecnologia NoSQL) o impacto não será tão grande, e a adaptação do sistema será restrita, evitando impactos globais na aplicação.

Mãos a obra

Pare demonstrar o uso destes design patterns e do Entity Framework 4.1 criaremos um cadastro simples de carros e suas respectivas montadoras.

1 – Abra o Microsoft Visual Studio 2010 e crie uma solução em branco.
2 – Adicione um projeto class library, no nosso exemplo este projeto chamará SampleCore.
3 – Apague o arquivo “Class1.cs” que é criado automaticamente pelo Visual Studio. Faça referências ao namespace “System.Data.Entity” e ao Entity Framework 4.1, geralmente esta localizado no caminho C:\Program Files (x86)\Microsoft ADO.NET Entity Framework 4.1\Binaries\EntityFramework.dll, o download do EF 4.1 pode ser feito neste link: http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=8363
4 – Crie três pastas dentro do projeto, chamadas Model, Controller e Data.
5 – Crie as classes Carro e Montadora dentro de Model conforme os exemplos a seguir:

Observe que para representar o relacionamento um para muitos (entre a montadora e os carros) utilizamos o tipo de dados ObservableCollection. ObservableCollection representa uma coleção de dados dinâmica que fornece notificações quando os itens são adicionados, removidos ou quando toda a lista é atualizada.

6 – Agora vamos começar a trabalhar com nossa camada de acesso a dados. Antes de qualquer coisa, criaremos duas interfaces para nossos repositórios de montadoras e carros. As interfaces devem ser criadas dentro de Model e devem implementar a seguinte estrutura:

Crie dentro da pasta Data uma classe chamada ContextoBancoDados e faça-a herdar de DbContext (namespace System.Data.Entity dentro do assembly EntityFramework.dll). E implemente-o conforme o código abaixo:

Caso o banco de dados não exista, e nenhuma string conexão tenha sido fornececida, então será criada uma base de dados local, cujo nome será igual a assinatura da classe dbcontext, isto é, o namespace da qual a classe pertence concatenado com o nome da classe dbcontext. Por exemplo, se sua classe dbcontext pertencer ao namespace “NomeDoCliente.NomeDoProjeto.Repositorio” e sua classe datacontext se chamar “ContextoBancoDados” então o nome de seu banco de dados será “NomeDoCliente.NomeDoProjeto.Repositorio.ContextoBancoDados”… Não parece ser uma boa prática um nome deste tamanho com características de nomenclatura tão específicas, então recomendo que sempre seja informada uma string de conexão, como no exemplo anterior.

Obs.: Para este exemplo deixei a string de conexão fixa (“chumbada”) no código… Esta realmente não é uma boa prática, o melhor neste caso é deixar a string de conexão em um arquivo configurável de sua aplicação. Para este cenário procure utilizar recursos nativos, como os arquivos App.Config e Web.Config.

7 – Para garantir a criação de seu banco de dados no primeiro acesso procure deixar fixo em algum lugar estratégico de sua aplicação a chamada para o método de criação da base. Não é uma boa prática tornar esse bloco de criação do banco de dados algo que será sempre validado e executado, pois isso pode consumir tempo e recursos operacionais. Então, como dica, os dois locais que acredito serem os ideais para este tipo de procedimento:
– Evento Application Start do Global.asax – no caso de aplicações web.
– Método Main() do arquivo Program.cs – no caso de aplicações desktop e console.

Mais para frente, neste mesmo post, irei demonstrar os comandos necessários para criação do banco de dados.

8 – Para implementação do design pattern DAO e utilização do Entity Framework 4.1 implementaremos as classes RepositorioMontadora e RepositorioCarro dentro da pasta Data da seguinte forma:

Para encapsular os comandos de criação do banco de dados, encapsularemos seu comportamento em uma classe chamada BancoDadosRepositorio implementada por uma interface chamada IFonteDadosRepositorio, conforme o código a seguir:

9 – Agora que temos criadas nossas entidades e nossos repositórios, poderemos implementar nossa classe controller que irá gerenciar os acessos as nossas fontes de dados, além de fazer ponte com nossa camada de visão. Nesta classe, por conta da simplicidade de nosso exemplo, iremos implementar as regras de persistência das montadoras e dos carros no mesmo controller. Da seguinte maneira:

10 – Nesses momentos já temos nossa camada de DAO pronta, além das camadas model e controller (pertencentes ao MVC) também concluídas. O próximo passo agora é implementar a camada de visão. Para este exemplo criaremos uma aplicação console, pois no momento a estrutura de nossa aplicação tem maior relevância do que a interface. Nesta demonstração criamos uma aplicação console chamada SampleConsole, e fizemos referência para o projeto SampleCore, para que conseguíssemos acessar suas classes. Nossa aplicação console deverá se parecer com algo como:

A estrutura da aplicação deve ficar como a imagem a seguir:

Para fazer o download acesse este link: http://code.msdn.microsoft.com/Entity-Framework-41-MVC-DAO-4860e78c

Por
Fernando Henrique Inocêncio Borba Ferreira.

Entity Framework 4.1

10/10/201103/11/2011 Fernando H. I. B. FerreiraDeixe um comentário

O Entity Framework 4.1 (EF 4.1) é um release que funciona sobre o ADO.Net Entity Framework incluso no .Net Framework 4.0. O EF 4.1 trás como novidade um novo DbContext e oficializa o Code First, antes um projeto paralelo do time de ADO.Net.

O Code First objetiva a configuração do modelo e criação do banco de dados a partir de nossas classes C# ou Visual Basic .Net, e/ou o mapeamento de um banco de dados existente.

Quais as novidades?
DbContext API – A nova classe System.Data.Entity.DbContext é uma versão alternativa ao ObjectContext, e é a classe preferencial para integração com banco de dados.
DbSet – Versão simplificada do ObjectSet, perfeita para fazer CRUD (Create, Retrive, Update e Delete) de um tipo existente do modelo.
ADO.Net DbContext Generator T4 Templates – ferramenta geradora de entidades POCO (Plain-Old CLR Objects).
Validation – O DbContext automaticamente valida entidades antes de salvá-las no banco de dados.
Code First – Code First permite a construção de modelos de bancos de dados através de nossas classes C# e Visual Basic .Net, além da adição de configurações através da atributos nas classes ou configurações no DbContext.

Vamos abordar mais sobre o Entity Framework 4.1 neste espaço nos próximos meses, a fim de ampliar o conhecimento da comunidade sobre essa tecnologia tão fantástica.

Por
Fernando Henrique Inocêncio Borba Ferreira.

Introdução ao Entity Framework Code First CTP 5

11/08/201111/08/2011 Fernando H. I. B. Ferreira6 Comentários

O objetivo deste post é apresentar o funcionamento do Entity Framework Code-First CTP 5. Este conjunto de bibliotecas ainda não está disponível na instalação do Visual Studio 2010, nem na instalação do Microsoft .Net Framework 4, pois ainda está em fase de testes e melhorias, por isso que ainda é um CTP (Community Technology Previews). O EF Code-First, apesar de ser um CTP, já está na versão 5, e apresenta muitas facilidades que auxiliam os desenvolvedores de software.

Nas próximas linhas apresentarei um exemplo de como trabalhar com o EF Code-First. Neste exemplo utilizo o conceito POCO (Plain Old CLR Objects), já discutido em um post anterior. Faremos a persistência dos dados de algumas entidades no banco de dados, e o EF Code-First ficará encarregado de fazer o mapeamento objeto-relacional para nossa aplicação.

Para utilizar o Entity Framework Code-First CTP 5 faça o download do mesmo neste link e siga os seguintes passos:

1 – Crie as tabelas no banco de dados Microsoft SQL Server, conforme o script abaixo:

2 – No Visual Studio 2010, crie uma solution em branco. Para este exemplo criei uma solution com o nome “SolutionEF_CTP5”.

3 – Adicione um projeto Class Library a solution. Para este projeto utilizei o nome “EFCTP5.Data”.

4 – Crie as classes Cliente, Endereco, Solicitacao conforme o código abaixo:

5 – Após a adição destas classes, faça referências as DLLs:

System.Data.Entity
EntityFramework
(geralmente localizada em C:\Program Files (x86)\Microsoft ADO.NET Entity Framework Feature CTP5\Binaries\)
System.Configuration

6 – Criar a classe de contexto, que irá administrar as requisições com a base de dados. Faça esta classe herdar de DbContext (System.Data.Entity). Adicione propriedades para representação das tabelas utilizando o tipo de dados DbSet – este tipo de dados é próprio para representação de coleções e entidades que podem servir para construção de queries. Sobrescreva o método “OnModelCreating”, com o objetivo de evitar a convenção de que o nome das tabelas devem estar no plural (pluralizados). Adicione um bloco de código no construtor desta classe para que a string de conexão seja preenchida sempre que o contexto de banco de dados for instanciado.

8 – Criei um projeto console para testar a aplicação e adicione referência ao projeto criado anteriormente e a DLL do Entity Framework Code First CTP 5.

9 – Adicione um arquivo “App.Config” ao projeto e insira o seguinte bloco de configuração atribuindo uma string de conexão para o seu banco de dados:

10 – Adicione o código abaixo, na aplicação console, para testar a inclusão de novos registros.

11 – Adicione o código abaixo, na aplicação console, para a consulta de registros cadastrados na base de dados.

[]s! e até o próximo…

Utilizando ADO.Net POCO Entity Generator

10/08/201103/11/2011 Fernando H. I. B. Ferreira4 Comentários

Uma nova abordagem de mapeamento objeto-relacional é o POCO (Plain Old CLR Object), que permite a utilização de nossas próprias classes como entidades dentro do modelo de mapeamento. Esta abordagem preza a utilização de classes simples, que não façam referência a frameworks especializados, que não dependam de soluções de terceiros, que não implementem nenhuma interface especial e que não dependam de nenhuma hierarquia de namespace.

O ADO.Net POCO Entity Generator é um template do Visual Studio 2010 que auxilia na construção de projetos que adotem o POCO criando entidades a partir de um modelo de dados. Neste post veremos quais os passos necessários para adoção desta técnica em projetos e como utilizar este template do Visual Studio 2010.

1 – Crie a tabela Person no banco de dados, conforme o script SQL abaixo:

2 – Crie uma solution no Visual Studio 2010 em branco.

3 – Adicione dois projetos Class Library a solution, a estes novos projetos atribua os nomes Data e Entities.

4 – Selecione o projeto Data e adicione um novo item utilizando o template ADO.Net Entity Data Model. No exemplo, criei com o nome dbModel.edmx. Este item é aquele comumente utilizado para adições de mapeamentos objeto-relacionais através do Entity Framework. Nas telas seguintes devem ser definidas: a conexão com o banco de dados e as tabelas que serão mapeadas. Neste exemplo apenas mapeei a tabela Person.

5 – Após fazer o mapeamento utilizando o Entity Framework, será preciso instalar o template ADO.Net POCO Entity Generator (caso o mesmo não esteja instalado). Clique em “Tools/Extension Manager”, selecione a aba Online Gallery e na caixa de pesquisa (localiza no canto superior direito) e pesquise por “T4”. Após a exibição dos resultados, instale os templates: “ADO.Net C# POCO Entity Generator” e “ADO.Net C# Web Site POCO Entity Generator” (caso a sua linguagem preferida seja VB.Net, então instale os templates próprios para a mesma, eles também estão disponíveis no resultado da consulta feita anteriormente).

6 – Após o download dos templates, volte a ferramenta de mapeamento, clique com o botão direito sobre uma das entidades mapeadas e seleciona a opção “Add Code Generation Item”.

7 – Adicione um novo item utilizando o template ADO.Net POCO Entity Generator. Neste exemplo atribui o nome “ModelPoco.tt”.

8 – Serão criados dois arquivos “ModelPoco.Context.tt” e “ModelPoco.tt”. O arquivo “ModePoco.tt” constrói as entidades, enquanto que o arquivo “ModelPco.Context.tt” gera o contexto tipado. Mova o arquivo “ModePoco.tt” Para o projeto Entities, a fim deixar o projeto classe projeto com suas respectivas responsabilidades separadas, sendo: Data, com acesso aos dados e o Entities, representando as entidades. Adicione no projeto Data referência para o projeto Entities.

9 – Dentro de “Modelo.tt”, na linha 22, altere o caminho do arquivo de mapeamento do Entity Framework para “..\Data\dbModel.edmx”. Isso fará com que a geração das entidades aponte para o arquivo correto, já que mudamos o arquivo de projeto.

Dentro de “ModelPoco.Context.tt”, vá até a linha 44, adicione uma referência para Entities, para que a geração de estruturas POCO possa identificar os tipos de dados utilizados no contexto.

Acesse as propriedades do arquivo “ModelPoco.tt” e altere a propriedade Custom Tool Namespace para “Entities”, faça o mesmo para o arquivo “ModelPoco.Context.tt”, mas modifique o valor da propriedade Custom Tool Namespace para “Data”. Esse passo é importante para que a geração de dados seja feita utilizando os namespaces previstos.

10 – Para testar o código, dentro da solution, crie um novo projeto utilizando o template Console Application. Dentro deste novo projeto faça referência as DLLs: Data, Entities e System.Data.Entity. Copie o arquivo “App.Config” que está localizado no projeto Data para este novo projeto, este passo é importante pois a string de conexão está localizada no mesmo.

11 – Para inserir novos registros utilize o código a seguir:

12 – Para consultar dados da base de dados utilize o código a seguir:

[]s! e até o próximo…

Por
Fernando Henrique Inocêncio Borba Ferreira.

Fernando Henrique Ferreira

while(alive) { this.WriteCode(); }

Tag: Entity Framework

EntityTypeConfiguration

EF41 – Inicializadores de Banco de Dados

Construindo sua camada de acesso a dados com o Entity Framework 4.1

Entity Framework 4.1 – Armazenamento de arquivos

Entity Framework 4.1 – Validations

Entity Framework – Data Annotations

Entity Framework 4.1 + MVC + DAO

Entity Framework 4.1

Introdução ao Entity Framework Code First CTP 5

Utilizando ADO.Net POCO Entity Generator