Entity Framework 4.1 – Armazenamento de arquivos

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

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.

efValidationPeople

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.

efValidationDataBaseContextFull

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.

efValidationPeopleFull

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.

efGetValidationErrors

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:

efCapturaDeErros

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

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

figuraAtributoKey

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.

figuraDataAnnotationRequired

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.

figuraMaxLengthMinLength

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.

figuraNotMapped

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.

figuraComplexType01

figuraComplexType02

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.

figuraAtributoTable

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.

figuraAtributoColumn

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.

figuraForeignKey

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.

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.

Entity Framework 4.1

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.

Table-Valued Parameters – Utilizando o tipo de dados tabela

Em versões anteriores ao SQL Server 2008 não é possível utilizar tabelas como parâmetro de Stored Procedures. Quando temos de enviar múltiplos dados para o banco de dados, acabamos por enviar tais dados um de cada vez, linha por linha, orientados por um laço de repetição. O SQL Server 2008 proporciona um contorno para esta solução através do uso de Table-Valued Parameters. Os Table-Valued Parameters permitem a passagem de tabelas como parâmetro para Stored Procedures.

Para a utilização deste recurso é necessário seguir um conjunto de passos, vou enumerá-los a seguir:

1 – Tipo dados de tabela

A primeira coisa a se fazer é criar um tipo de dados de tabela (table type). Para a criação deste tipo de dados deve-se utilizar a seguinte sintaxe.

CREATE TYPE dbo.PointAttention AS TABLE
(
Id int NOT NULL,
Description varchar(100) NOT NULL,
Date datetime NOT NULL,
PRIMARY KEY (Id)
)
GO

2 – Trabalhando com o tipo de dados de tabela

Para utilizar este tipo de dados, na sintaxe Transaction-SQL, é preciso criar uma variável deste tipo de dados e então valorizá-la como se fosse uma tabela.

DECLARE @varPoint PointAttention

INSERT INTO @varPoint(Id,Description,Date)
VALUES (100,’Alerta de segurança 1′,’2011-01-20′),
(101,’Alerta de segurança 2′,’2011-01-20′),
(102,’Alerta de segurança 3′,’2011-01-20′),
(103,’Alerta de segurança 4′,’2011-01-20′),
(104,’Alerta de segurança 5′,’2011-01-20′)

SELECT * FROM @varPoint

Assim como qualquer outra tabela, variáveis desse tipo podem ser utilizadas para popular outras tabelas ou servirem em clausulas JOIN dentro de comandos de seleção.

* Observação: por ser uma variável, será limpa da memória automaticamente assim que o escopo de execução for concluído, não consumindo recursos além daqueles necessários durante seu bloco de execução.

3 – Utilizando tipos de dados tabela como parâmetro de Stored Procedures

Agora vamos ao ponto focal deste texto, que é receber uma estrutura de tabela como parâmetro de uma Stored Procedure.

Para execução do exemplo, criemos uma tabela que possua uma estrutura semelhante a do nosso tipo de dados tabela.

CREATE TABLE dbo.tbPointAttention
(
pntId int NOT NULL PRIMARY KEY,
pntDescr varchar(20) NOT NULL,
pntDate datetime NOT NULL
)
GO

Agora, para construção da Stored Procure mantemos a mesma sintaxe, apenas incluindo um parâmetro com o mesmo tipo de dados de tabela criado anteriormente.

CREATE PROC spInsertPAttention @PAttentions PointAttention READONLY
AS
INSERT INTO tbPointAttention
(pntID, pntDescr, pntDate)
SELECT ID,Description,Date
FROM @PAttentions
GO

4 – Consumindo tipos de dados tabela através de aplicações .Net

O ponto chave de utilização deste novo tipo de estrutura é a utilização do tipo de dado SqlDbType.Structured (presente no namespace System.Data.SQLClient, disponível a partir do Microsoft .Net Framework 3.5).

O exemplo abaixo demonstra como essa interação pode ser codificada utilizando C#.

Capturar

 

Vantagens da utilização de Table-Valued Parameters:
– Simplificação da lógica do projeto;
– Permite aos desenvolvedores construírem aplicações performáticas;

Referências:
http://msdn.microsoft.com/en-us/library/bb510489.aspx
http://msdn.microsoft.com/en-us/library/bb675163.aspx
http://www.sqlteam.com/article/sql-server-2008-table-valued-parameters

 

Por
Fernando Henrique Inocêncio Borba Ferreira.