[Resolvido] WPF - DataBinding com Entity Framework 4.1 e Code Fir

[RSS iMasters 5]

Neste artigo, vamos abordar novamente os recursos do Code First do Entity Framework 4.1. Dessa vez, em uma aplicação WPF, na qual iremos usar tipos definidos no modelo como fonte de dados em uma apresentação mestre-detalhes.

A versão 4.1 do Entity Framework trouxe grandes melhorias em relação à versão anterior como:

• Suporte a POCO: Agora você pode definir as entidades sem a necessidade de classes base, ou atributos de persistência de dados;
• Suporte a Lazy Loading (carregamento tardio): Você já pode carregar sub-objetos de um modelo sob demanda, em vez de carregá-los antecipadamente;
• Suporte a N-Camadas e Auto-Rastreamento de Entidades: Trata cenários nos quais as entidades são passadas entre camadas, ou chamadas web sem estado (stateless);
• Melhor suporte para geração de SQL e SPROC: EF4 executa um código SQL melhorado, e inclui uma integração melhor com SPROCs (stored procedures - procedimentos armazenados);
• Suporte à Pluralização Automática: o EF4 inclui suporte à pluralização automática de tabelas (Ex: Produtos -> Produto);
• Testabilidade Melhorada: O objeto de contexto do EF4 pode agora ser mais facilmente imitado usando interfaces;
• Suporte melhorado para os Operadores LINQ: o EF4 agora oferece suporte completo para os operadores LINQ.

fonte: ScottGu's Blog

Na primeira versão do Entity Framework, praticamente não havia o que é conhecido como Code-First (Código Primeiro, ou Antecipado), ou seja, a possibilidade de gerar o modelo de negócios e suas entidades sem ter que, primeiro, criar o banco de dados.

Quando decidimos usar o Code-First, não precisamos começar nossa aplicação criando o banco de dados, ou definindo um esquema. Ao invés disso, podemos iniciar escrevendo classes .NET (POCO) para definir o modelo de objetos do nosso domínio sem ter que misturar a lógica de persistência de dados com as classes de negócio.

O Entity Framework, por padrão, adota algumas convenções (conventions) que ele utiliza para realizar algumas operações, como a criação do banco de dados e de tabelas e definição de nomes, chaves primárias, entre outros.

POCO - Plain Old CLR Object - são classes simples de domínio que possuem apenas get/sets e um construtor, e que não dependem de nenhum framework; as classes POCO não são obrigadas a herdar de nenhuma outra classe, ou implementar nenhuma interface. Portanto, as classes POCO  são independentes de frameworks.

No exemplo deste artigo, vamos definir um modelo com dois tipos que participam de um relacionamento um-para-muitos:

• Curso (principal)

• Aluno (dependente)

Os recursos necessários para acompanhar o artigo são (todas as versões usadas são gratuitas e podem ser baixadas nos links abaixo):

• Visual Basic 2010 Express Edition

• Entity Framework 4.1

• SQL Server 2008 Express Edition

Criando a estrutura da solução

Passo 1 - Criando a solução e o projeto no qual residirá o nosso modelo e a referência ao Entity Framework e o Code-First:

Abra o Visual Basic 2010 Express Edition e no menu File clique em New Project.

Selecione a linguagem Visual Basice o modelo Class Library; informe o nome EscolaModel e clique em OK.

No menu File clique em Save All. Já na janela Save Project informe:

• Name (nome do projeto) = EscolaModel
• Solution Name (nome da solução) = WPF_CodeFirst
• Create directory for solution = tem que estar marcado

Passo 2 - Criando o projeto WPF

No menu File clique em Add, e a seguir em New Project.

Selecione a linguagem Visual Basic e o modelo WPF Application, informe o nome WPF_Interface e clique em OK.

Ao final, na janela Solution Explorer você deverá ver uma solução contendo dois projetos, conforme a figura abaixo:

Definindo o modelo

Vamos agora trabalhar com o projeto EscolaModel e definir o modelo que vamos usar em nossa aplicação WPF. O nosso modelo simplificado pode ser visto no diagrama de classes a seguir:

O nosso modelo de negócio consiste de duas classes:

• Curso
• Aluno

Esse modelo representa um Curso que possui um ou mais alunos. Temos aqui uma associação que representa o relacionamento um-para-muitos, que é usado quando uma entidade A pode se relacionar com uma, ou mais entidades B. Esse relacionamento é representado pelo sinal: 1:N ou 1: *, que expressa a cardinalidade do relacionamento.

A cardinalidade é um conceito importante para ajudar a definir o relacionamento. Ela define o número de ocorrências nele. Para determinar a cardinalidade, deve-se fazer a pergunta relativa ao relacionamento em ambas as direções. No exemplo a seguir, temos:

• Um Curso possui quantos alunos?  R: no mínimo um e no máximo N;
• Um aluno está alocado em quantos cursos? R: no mínimo em um e no máximo em 1.

Vamos usar o Entity Framework 4.1 e o modelo de desenvolvimento Code-First escrevendo as classes POCO, que definem o nosso modelo conceitual. As classes não precisam derivar de qualquerclasse base, ou implementar alguma interface.

No projeto EscolaModel, clique com o botão direito do mouse e selecione Add Reference. A seguir, selecione a guia Browse da janela Add Reference e localize o arquivo EntityFramework.dll na pasta onde você instalou o Entity Framework 4.1.

Agora altere o nome da classe class1.vb para EscolaModel.vb e digite o código abaixo, que define as nossas classes do domínio: Curso e Aluno.

Nota: Para simplificar, eu estou criando as classes Curso e Aluno no arquivo EscolaModel.vb, mas poderia criar em arquivos distintos.

Imports System.ComponentModel

Imports System.Collections.ObjectModel

 

Public Class Curso

 

Public Sub New()

Me.Aluno = New ObservableCollection(Of Aluno)()

End Sub

 

'chave primaria

Private _cursoID As Integer

Public Property CursoID() As Integer

Get

Return _cursoID

End Get

Set(value As Integer)

_cursoID = value

End Set

End Property

 

Private _nome As String

Public Property Nome() As String

Get

Return _nome

End Get

Set(value As String)

_nome = value

End Set

End Property

 

'propriedade de navegação

Private _Alunos As ObservableCollection(Of Aluno)

Public Property Aluno() As ObservableCollection(Of Aluno)

Get

Return _Alunos

End Get

Private Set(value As ObservableCollection(Of Aluno))

_Alunos = value

End Set

End Property

End Class

 

Public Class Aluno

 

'chave primaria

Private _alunoID As Integer

Public Property AlunoID() As Integer

Get

Return _alunoID

End Get

Set(value As Integer)

_alunoID = value

End Set

End Property

 

Private _nomeAluno As String

Public Property NomeAluno() As String

Get

Return _nomeAluno

End Get

Set(value As String)

_nomeAluno = value

End Set

End Property

 

Private _email As String

Public Property Email() As String

Get

Return _email

End Get

Set(value As String)

_email = value

End Set

End Property

 

' chave estrangeira

Private _cursoID As Integer

Public Property CursoID() As Integer

Get

Return _cursoID

End Get

Set(value As Integer)

_cursoID = value

End Set

End Property

 

'propriedade de navegação

Private _Curso As Curso

Public Overridable Property Curso() As Curso

Get

Return _Curso

End Get

Set(value As Curso)

_Curso = value

End Set

End Property

End Class

A propriedade Alunos na classe Curso e a propriedade Curso na classe Aluno são as propriedades de navegação que fornecem uma maneira de navegar através de uma associação, ou relacionamento entre duas entidades retornando uma referência para um objeto (se a multiplicidade é um, ou zero-ou-um), ou uma coleção (se a multipliciade é muitos).

O Entity Framework nos dá a opção de carregar as entidades relacionadas a partir do banco de dados de forma automática sempre que acessarmos a propriedade de navegação.

Com esse tipo de carga de objetos (conhecido como lazy loading), esteja atento para que cada propriedade de navegação que for acessada resulte em um consulta separada, executada no banco de dados, se a entidade ainda não estiver no contexto.

Quando usamos classes POCO para definir as nossas entidades, o lazy loading é ativado pela criação de instâncias de tipos proxy derivados em tempo de execução que então sobrescrevem as propriedades virtuais para incluir a lógica lazy loading.

Definindo uma classe derivada DBContext que suporta o nosso modelo de entidades

Para começar a usar os objetos da entidades para acessar os dados, precisamos do contexto dos objetos definido em System.Data.Entity.DbContext, ou em System.Data.Objects.ObjectContext.

Podemos, então, definir uma classe que deriva de DbContext ou de ObjectContext e expor as propriedades de System.Data.Entity.DbSet ou deSystem.Data.Objects.ObjectSet para as entidades definidas no modelo.

O DbContext e o DbSet são um invólucro para ObjectContext e ObjectSet e fornecem uma API simplificada, que podemos usar para realizar as tarefas comuns e que permitem que continuemos acessando os tipos que vamos precisar.

Vamos incluir uma nova classe no projeto EscolaModel clicando sobre o projeto com o botão direito do mouse. Clique em Add e, a seguir, em Class e escolha o modelo Class, informando o nome EscolaModelEntidades.vb e clique no botão Add.

A seguir, digite o código abaixo que cria a classe EscolaEntidades, que herda de DbContext:

Imports System.Data.Entity

 

Partial Public Class EscolaEntidades

Inherits DbContext

 

Public Sub New()

End Sub

 

Private _Cursos As DbSet(Of Curso)

Public Property Cursos() As DbSet(Of Curso)

Get

Return _Cursos

End Get

Set(value As DbSet(Of Curso))

_Cursos = value

End Set

End Property

 

Private _alunos As DbSet(Of Aluno)

Public Property Alunos() As DbSet(Of Aluno)

Get

Return _alunos

End Get

Set(value As DbSet(Of Aluno))

_alunos = value

End Set

End Property

End Class

A classe DbContext permite o acesso mais fácil a consultas e permite trabalhar com os dados das entidades como objetos.

Esse código usa uma abordagem de "convenção sobre configuração". Nessa abordagem, você confia em convenções de mapeamento comuns, em vez de, explicitamente, configurar o mapeamento. Por exemplo, se uma propriedade em uma classe contém a string "ID" ou "Id", ou o nome da classe seguido por Id (Id pode ser qualquer combinação de letras maiúsculas e minúsculas), o Entity Framework trata essas propriedades como chaves primárias por convenção.

Essa abordagem funciona na maioria dos cenários de mapeamento de banco de dados comum, mas o Entity Framework fornece maneiras para que você possa substituir essas convenções. Por exemplo, se você deseja explicitamente definir uma propriedade para ser uma chave primária, você pode usar data annotations.

Dessa forma, definimos as nossas entidades do modelo usando os recursos do Entity Framework no modelo de desenvolvimento Code-First.

Na segunda parte do artigo, criarei a aplicação WPF e vou realizar a vinculação de dados (databinding) no modelo mestre-detalhes.

 

http://imasters.com.br/artigo/22361/dotnet/wpf-databinding-com-entity-framework-41-e-code-first-parte-01