Entity Framework 5 (Internals)

Neste post gostaria de descrever alguns procedimentos importantes para execução de queries via Entity Framework 5. Acredito que a explicação do funcionamento e da existência destes procedimentos pode ajudar na resolução de cenários mais avançados e no entendimento do funcionamento do Entity Framework.

Unicorn-Sugar-Skull

Cold e Warm Queries

A primeira vez que uma query é executada, o Entity Framework executa muito trabalho para carregar e validar o modelo de dados utilizado.

Saiba mais

About these ads

SelectMany – Simplificando consultas e estruturas

Olá,

Hoje vamos discutir sobre um query method chamado SelectMany e como ele pode facilitar (e muito) nossas consultas com objetos aninhados.

selectMany2

Saiba mais

Integrando MongoDB com .Net e LINQ

Olá!

Na última sexta-feira (13 de Julho de 2012), estive presente no MongoDB São Paulo 2012. Um evento organizado pela 10Gen sobre o uso do MongoDB. Para quem não sabe o MongoDB é um banco de dados No-SQL, isto é, não trabalha com o paradigma relacional, não trabalha com colunas e nem linhas. A persistência dos dados é toda baseada na estrutura das entidades de suas classes. Isto é bastante favorável, pois não exige a existência de uma estrutura rígida baseada em um schema. Algum tempo atrás eu fiz uma série de experimentos com o Db4Objects (http://ferhenriquef.com/?s=db4o), um banco de dados orientado a objetos que funciona de forma parecida.

Um adendo: quando fiz a faculdade de Sistemas de Informação, na Universidade Presbiteriana Mackenzie, eu tive a possibilidade de escolher uma ênfase para o meu curso, e no caso escolhi a ênfase em Banco de Dados. Então, isso explica alguns dos meus posts e alguns dos experimentos neste blog. Sou vidrado em tecnologias diferentes de armazenamento de dados, mas acho que isso todos já perceberam.

mongoNet

Saiba mais

Uso de Include em consultas com o Entity Framework Code First

Um tópico muito discutido nos fóruns de acesso a dados (http://social.msdn.microsoft.com/Forums/pt-BR/adoptpt/threads) e LINQ (http://social.msdn.microsoft.com/Forums/pt-BR/linqpt/threads) é o uso de Lazy Load no Entity Framework.

O Lazy Load (ou Lazy Loading) nada mais é do que um mecanismo adotado pelos frameworks de persistência a dados para carregar as informações sobre demanda, isto é, carregar em memória apenas os dados de propriedades que não sejam relacionamentos para outras entidades. Este tipo de recurso minimiza o consumo de memória, o trafego de dados pela rede e os recursos de consulta do banco de dados, além de tornar a consulta mais rápida. Saiba mais

Agrupamento de dados via LINQ e Lambda

Nos últimos tempos, participando do fórum do MSND sobre LINQ (http://social.msdn.microsoft.com/Forums/pt-br/linqpt/threads ), notei que muitas dúvidas surgiram com relação a sintaxe do LINQ para o agrupamento de dados. Dessa forma, espero neste post fazer um breve overview da sintaxe do LINQ para agrupamento, e também demonstrar a sintaxe Lambda correspondente.

Contexto do exemplo
Para estes exemplos utilizei uma estrutura de dados chamada Cidade. Esta estrutura contém: o nome da cidade, a quantidade de habitantes que ali vivem e o estado desta cidade dentro do país.

Os dados utilizados para a execução do exemplo estão chumbados no código e são originados do seguinte método: Saiba mais

Windows Phone Mango e Microsoft SQL CE

Para armazenar e recuperar dados em um banco de dados local as aplicações Windows Phone utilizam LINQ to SQL. O LINQ to SQL é um recurso nativo do Framework 3.0 e foi um dos recursos que mais chamaram atenção no lançamento do Microsoft Visual Studio 2008. O LINQ to SQL, como já dito em outros posts, fornece mapeamento objeto-relacional entre a aplicação e bancos de dados relacionais, além disso é um recurso extremamente poderoso, que permite a construção de consultas utilizando sintaxe C# e VB.Net.

O Windows Phone Mango utiliza como base de dados o Microsoft SQL CE, versão compacta do famoso banco de dados Microsoft SQL, e própria para dispositivos móveis.

Aqui vamos apresentar o exemplo de uma aplicação que armazena e remove dados do banco de dados Microsoft SQL CE, utilizando como plataforma o Windows Phone Mango.

1o – Crie a aplicação utilizando o template Windows Phone Application.

2o – Ao ser perguntado sobre a versão da plataforma Windows Phone, selecione a opção Windows Phone OS 7.1.

3o – Dentro do projeto crie três pastas, sendo elas: DAO, Controller e Model.
windowsPhone01

4o – Faça referência a DLL System.Data.Linq.
windowsPhone02

5o – Dentro da pasta Model, criada anteriormente, crie a classe DataItem conforme a imagem a seguir.
windowsPhone03

6o – Adicione os atributos de mapeamento objeto-relacional LINQ para criar o mapeamento entre a classe e a tabela do banco de dados do Microsoft SQL CE. Faça referência ao namespace System.Data.Linq.Mapping.
windowsPhone04

7o – Dentro da pasta DAO crie uma classe chamada DataBaseContext, e a faça herda DataContext, classe presente no namespace System.Data.Linq. Esta classe será nosso data context e será responsável por fazer a ponte entre a aplicação e o banco de dados. Dentro da classe crie um atributo público chamado DataItems e que seja do tipo Table<DataItem>, este atributo representará nossa tabela no banco de dados. A classe DataBaseContext deverá se parecer com a seguinte implementação:
windowsPhone05

8o – Agora que temos nossa entidade e nosso data context, devemos criar uma classe que encapsule os comando com o banco de dados, por isso criaremos dentro da pasta DAO a classe DAOProvider. Esta classe representará nossa camada de acesso a dados e encapsulará os comandos feitos para o banco de dados. Nesta classe implementaremos quatro métodos, sendo eles: CreateDataBase, método que criará a base de dados; GetDataItems, método que retornará todos os dados que estiverem no banco de dados; Save, salva novos registros na base de dados; Remove, remove os dados do banco de dados. A implementação funcionará da seguinte forma:
windowsPhone06

9o - Para intermediar as chamadas entre a camada de visão e o repositório criaremos uma classe de controle que faça chamadas ao repositório. A vantagem de utilizar este tipo de classe é a possibilidade de encapsultar o repositório e poder adicionar filtros que intermediem o acesso aos dados do banco de dados. Esta classe deverá ser implementada como demonstrado a seguir:
windowsPhone07

10o – Finalmente vamos construir a interface do nosso aplicativo. Esta será uma interface bastante simples, deverão ser adicionados os seguintes itens: um textbox, um listbox e um botão (mais detalhes do layout poderão ser vistos no link para o download do exemplo, pois o layout do projeto não é o objetivo deste post).
windowsPhone08

11o – O único detalhe importante do layout é o modo como será feito o bind do listbox, pois na verdade ele será populado "na mão", isto é, os itens serão adicionados um-a-um (em um próximo post veremos como fazer isso de modo automático). Segue detalhe do XAML descrevendo o bind do listbox.
windowsPhone09

12o – A lógica da camada de visão deverá funcionar como o código apresentado a seguir. Como pode ser observado no código, ao clicar no botão Salvar um novo registro será incluso na base de dados, e ao clicar sobre qualquer item do listbox, o mesmo será removido do banco de dados.
windowsPhone10

Esta é uma introdução ao acesso a dados utilizando o Windows Phone e o Microsoft SQL CE. Espero que este post sirva como introdução para todos, e também espero que motive a construção de novos aplicativos para esta nova plataforma.

Para o download do exemplo acesse esse link: http://code.msdn.microsoft.com/Windows-Phone-Mango-e-SQL-81f15d55

[]s!

windowsPhone11

Atualizando dados utilizando o método Attach!!!!

O modo mais fácil de atualizarmos dados de nosso modelo no banco de dados é através do método Attach. Assim como utilizamos o InsertOnSumit para executarmos inclusões na base de dados, o método Attach pode ser bastante útil para atualizações de nossas entidades em nossas bases de dados.

Vamos supor uma classe chamada Arquivo:

AttachArquivo01

… e vamos utilizar uma data context como o seguinte:

AttachDataContext02

Em seguida, vamos criar um método para submeter nossas atualizações ao banco de dados:

AttachSalvar03

Observe que caso o valor de nossa propriedade Id seja distinto de ZERO, teremos de executar uma consulta na base de dados para retornar a instância que desejamos e assim fazermos o “de/para” dos dados de nossa instância (com valores atualizados) para a instância vinda do banco de dados.

Se utilizássemos o método Attach iríamos reduzir a complexidade deste código e removeríamos uma consulta desnecessária ao banco de dados para buscar a instância que lá existe, desta maneira:

AttachSalvar04

Simples! Veja que a complexidade do código foi reduzida e eliminamos uma consulta extra ao banco de dados, o que acaba gerando uma rotina de atualização mais rápida e performática.

Mas existe uma ressalva sobre este método: o Attach EXIGE que a instância de objeto passada por parâmetro não esteja vinculada a nenhum outro Data Context, isto é, caso a instância de objeto passada por parâmetro para o método Salvar tenha vindo diretamente de um Data Context, o attach não ocorrerá, e receberemos uma mensagem de erro, por isso, neste caso, a classe Arquivo implementa a interface ICloneable, resultando nesta estrutura:

AttachArquivo05

[]s e até a próxima! =]

 

Por
Fernando Henrique Inocêncio Borba Ferreira.

Utilizando ADO.Net POCO Entity Generator

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:

clip_image002

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

clip_image004

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

clip_image006

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.

clip_image008
clip_image010

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

clip_image012

clip_image014

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”.
clip_image016
7 – Adicione um novo item utilizando o template ADO.Net POCO Entity Generator. Neste exemplo atribui o nome “ModelPoco.tt”.

clip_image018

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.

clip_image020

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.

clip_image022

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.

clip_image024

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.

clip_image026

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

clip_image028

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

clip_image030

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

 

Por
Fernando Henrique Inocêncio Borba Ferreira.

Linq to SQL – Atributos de Mapeamento Objeto-Relacional

Quando trabalhamos com LINQ to SQL nosso mapeamento objeto-relacional pode ser construído de duas maneiras: através de um arquivo externo (XML Mapping Source) ou através do mapeamento das classes da aplicação (Attribute Mapping Source). Na grande maioria dos casos acabamos por realizar o mapeamento dos atributos das classes da aplicação e utilizamos o Object Relational Designer – assistente do Microsoft Visual Studio que gera o mapeamento do banco de dados automaticamente para nossa aplicação.

O mapeamento ocorre da seguinte maneira:
- O banco de dados é mapeado para uma instância de um DataContext.
- Uma tabela é mapeada para uma classe
- As colunas da tabela são mapeadas para as propriedades das classes

Podemos construir esse mapeamento manualmente, sem utilizar o assistente do Microsoft Visual Studio, a fim de tornar o código mais simples, gerenciável e inteligível. Para tanto devemos fazer uso dos atributos de mapeamento do LINQ, tais atributos estão contidos no namespace System.Data.Linq.Mapping. Para ter acesso a esses atributos precisamos fazer referência a dll System.Data.Linq.

O mapeamento de uma tabela vai se parecer com o código a seguir:

Mapclasses

… baseado na estrutura da seguinte tabela:

clip_image003

Comparando o código C# e o código SQL, podemos considerar alguns pontos:
- O atributo Table, localizado acima da definição da classe Customer, indica que esta classe corresponde ao mapeamento de uma tabela, mais especificamente a tabela tbMappingCustomer, especificada pelo valor definido na propriedade Name .

- O atributo Column indica que uma propriedade corresponde a uma coluna da tabela, isto é, o atributo Column simboliza o mapeamento entre uma coluna da tabela e uma propriedade da classe.

- O atributo Column possui diversas propriedades Name e CanBeNull são apenas algumas, mas são algumas das principais. Em um próximo post discutiremos outras possibilidades. A propriedade Name do atributo Column indica qual coluna da tabela deverá ser mapeada pelo LINQ to SQL, e a propriedade CanBeNull indica quais colunas aceitam valores nulos na base de dados.

- As propriedades IsDbGenerated e IsPrimaryKey são propriedades do atributo Column, que são utilizadas apenas na propriedade ID, pois essa propriedade mapeia a chave primária da tabela. A propriedade IsDbGenerated indica que o atributo possui valores gerados pelo próprio banco de dados, no nosso caso os valores dessa coluna da tabela são gerados automaticamente pelo Identity(1, 1) citado no código SQL. A propriedade IsPrimaryKey é autoexplicativa, ela indica se a propriedade corresponde ao mapeamento da chave primaria da tabela.

Para persistir as informações é preciso utilizar um objeto que faça a ponte entre a aplicação e o banco de dados, este objetivo é o DataContext. A função do DataContext é traduzir o mapeamento objeto-relacional para comandos que possam ser interpretados pelo banco de dados, assim como converter os dados retornados pelo banco de dados para as entidades do mapeamento objeto-relacional.

No caso, costumo criar uma classe que herde de um DataContext, e que para cada tabela, crie-se um atributo do tipo Table<E> que referencie uma entidade mapeada para a aplicação. Na imagem abaixo demonstro como faço essa implementação.

DataContext

Abaixo um exemplo de como unir a utilização do DataContext customizado, com as entidades mapeadas manualmente.

Implementacao

Obrigado.
[]s!

Referências indicadas:
http://oreilly.com/catalog/9780596519254
http://msdn.microsoft.com/en-us/library/system.data.linq.datacontext.aspx
http://blogs.microsoft.co.il/blogs/bursteg/archive/2007/09/23/24907.aspx
http://msdn.microsoft.com/en-us/library/bb386971.aspx

Aplicação em Camadas Utilizando LINQ – (Inclui exemplos de AjaxControlToolKit)

Esse é um exemplo de aplicativo em 4 camadas. A primeira camada é a Camada de Layout (página .aspx), a segunda camada é a Camada Estrutural(as entidades, seus métodos e propriedades), a terceira camada é onde faço uso da sintaxe do LINQ, podemos chamar essa camada de Camada de Persistência a Dados e por fim a quarta camada corresponde a Camada de Acesso a Dados(nessa camada o LINQ trabalha sozinho =D). Beleza, além disso temos o uso de alguns objetos do Ajax Control Tool Kit (Calendar Extender & Confirm Button Extender). Ponto importante: Observem que nas classes do LINQ eu alterei seus níveis de acesso, alterei todas para INTERNAL, assim respeitamos a regra de encapsulamento e teremos total controle sobre o que entra ou sai da base de dados… Dentro do exemplo existe um script do SQL pra criar as tabelas necessárias, além disso é preciso alterar a string de conexão… ps: não reparem no layout! ficou bem simples, mas a intenção era demonstrar o uso das camadas e do LINQ. =D

http://code.msdn.microsoft.com/Aplicao-em-Camadas-40c53736

Seguir

Obtenha todo post novo entregue na sua caixa de entrada.

Junte-se a 64 outros seguidores