Desenvolvimento Efetivo na Plataforma Microsoft: o livro.

Desenvolver software é complexo. E fazer isso de forma ágil, manutenível, gerando soluções escaláveis, performáticas, seguras e com alta disponibilidade é mais complexo ainda.

Diante desses desafios, o time de engenheiros de suporte a campo Modern Apps Brazil decidiu por reunir um conjunto de práticas e lições aprendidas em campo com a plataforma Microsoft em um livro. Esses engenheiros são focados na resolução de problemas críticos relacionados a ALM, IIS e .NET Framework na plataforma Microsoft.

clip_image001

Leia mais »

Publicidade

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 (https://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

Leia 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.Leia mais »

EntityTypeConfiguration

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 »

Anúncio de melhorias de performance do Entity Framework 5.0

É certo que o uso de ferramentas de mapeamento objeto-relacional reduzem nossa performance durante o acesso a base de dados. Esta perda pode parecer invisível e na maioria das vezes não sentimos esse impacto por ser uma diferença muitas vezes irrisória, já que tais diferenças são medidas em milissegundos ou microssegundos.

Alguns profissionais preferem não utilizar ferramentas de mapeamento objeto-relacional e adotam essa perda de performance como uma das justificativas para isso, mesmo que essa perda seja muitas vezes invisível.

Assim, desde os primórdios do LINQ, perguntou-se e inferiu-se muito sobre a performance das ferramentas de mapeamento objeto-relacional do Microsoft .Net Framework. E esta semana, o time de ADO.Net liberou um post interessante em seu blog (http://blogs.msdn.com/b/adonet/).Leia 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:Leia mais »

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

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:

diagrama

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:

Projects

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:

SetInitializer

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.

Conventions

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:

ComplexType01

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

ComplexType02

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.

dataEntity

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

1 – Herança

Herança

2 – Invoque ao construtor da classe base em nossas entidades

construtor

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.

IRepository

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:

IClientRepository

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

ClientRepository

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:

clientController

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 + MVC + DAO

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:

01

02

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:

03

04

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:

05

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:

060

070

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:

090

080

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:

100

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:

110

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

00000

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.

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