Mês passado, nós lançamos
(em Inglês) a versão Beta do VS 2010 Service Pack 1 (SP1). Você pode aprender mais
sobre o VS 2010 SP1 Beta a partir dos dois posts (em Inglês) de Jason Zander e a partir do post de Scott Hanselman (em Inglês) que cobre
algumas das novas capacidades habilitadas com ele. Você pode baixar e
instalar o VS 2010 SP1 Beta aqui.
Semana passada eu escrevi sobre o novo suporte do Visual Studio para o IIS Express
que estamos adicionando com o VS 2010 SP1. No post de hoje vou falar
sobre as novas ferramentas de suporte do VS 2010 SP1 para o SQL CE, e
mostrarei passo a passo alguns dos cenários legais que elas permitem.
SQL CE - O que ele é e por que você deveria se importar?
O
SQL CE é um motor de banco de dados gratuito que pode ser integrado a
uma aplicação, possibilitando um fácil armazenamento de dados.
Instalação de Banco de Dados não mais Necessária
O
SQL CE não requer que você execute uma instalação ou instale um
servidor de banco de dados, a fim de usá-lo. Você pode simplesmente
copiar os arquivos binários do SQL CE para o diretório \bin de sua
aplicação ASP.NET, e então sua aplicação pode usá-lo como um mecanismo
de banco de dados. Nenhuma instalação ou permissões de segurança
adicionais são necessárias para que ele seja executado. Você não precisa
ter uma conta de administrador na máquina. Basta copiar sua aplicação
Web em qualquer servidor e ela irá funcionar. Isto é verdadeiro mesmo em
aplicações medium-trust (nível de segurança média) rodando em um
ambiente de hospedagem.
O SQL CE é executado na memória dentro
de sua aplicação ASP.NET e será iniciado quando você acessar um banco de
dados SQL CE, e será desligado automaticamente quando a aplicação for
descarregada/parada. Bancos de dados SQL CE são armazenados como
arquivos que residem dentro da pasta \App_Data de suas aplicações
ASP.NET.
Trabalha com APIs de Dados Existentes
O
SQL CE 4 trabalha com APIs de dados existentes baseadas no .NET, e
suporta uma sintaxe de consulta compatível com o SQL Server. Isto
significa que você pode usar APIs de dados existentes como ADO.NET, bem
como ORMs de alto nível como o Entity Framework e NHibernate com o SQL
CE. Isso permite que você use as mesmas habilidades de programação de
dados e APIs de dados que você conhece hoje.
Suporta Cenários de Desenvolvimento, Teste e Produção
O
SQL CE pode ser usado em cenários de desenvolvimento, testes, e
cenários leves de produção. Com o lançamento do SQL CE 4, fizemos o
trabalho de engenharia para garantir que o SQL CE não irá quebrar ou
entrar em um estado de deadlock (impasse) quando usado em um cenário de
servidor multi-thread (como é o caso da ASP.NET). Esta é uma grande mudança a
partir de versões anteriores do SQL CE - que foram projetadas para
cenários cliente apenas e que explicitamente bloqueava sua execução em
ambientes de web-server. Começando com o SQL CE 4, você pode usá-lo em
um servidor web também.
Não há restrições de licença com o SQL CE. Ele também é totalmente gratuito.
Fácil Migração para o SQL Server
O
SQL CE é um banco de dados que pode ser integrado à aplicação - o que o
torna ideal para o desenvolvimento, testes e cenários leves de uso. Para sites e aplicações de grande porte, você provavelmente vai querer
migrar seu banco de dados para usar o SQL Server Express (que é
gratuito), SQL Server ou SQL Azure. Esses servidores permitem uma
escalabilidade muito melhor, mais recursos para desenvolvimento
(incluindo recursos como Stored Procedures - que não são suportadas no
SQL CE), assim como mais recursos avançados de gerenciamento de dados.
Nós
disponibilizaremos ferramentas de migração que permitem que você,
opcionalmente, tenha bancos de dados SQL CE e facilmente os atualize para
usar o SQL Server Express, o SQL Server ou SQL Azure. Você não
precisará alterar seu código quando atualizar um banco de dados SQL CE
para o SQL Server ou SQL Azure. Nosso objetivo é permitir que você seja
capaz de simplesmente alterar a string de conexão do banco de dados no
seu arquivo web.config para ter sua aplicação funcionando sem mais
esforços.
Novo Suporte a Ferramentas para o SQL CE no VS 2010 SP1
O
VS 2010 SP1 inclui um suporte muito melhorado para ferramentas do SQL CE,
e adiciona suporte para usar o SQL CE dentro de projetos ASP.NET pela
primeira vez. Com o VS 2010 SP1 agora você pode:
- Criar novos bancos de dados SQL CE
- Editar e modificar o esquema e índices de bancos de dados SQL CE
- Preencher bancos de dados SQL CE com dados
- Usar o designer do Entity Framework (EF) para criar camadas do modelo com base em bancos de dados SQL CE
- Usar
a biblioteca EF Code First para definir camadas do modelo no código, e em seguida,
criar um banco de dados SQL CE a partir delas, e, opcionalmente, editar o
BD com o VS
- Instalar bancos de dados SQL CE em servidores
remotos utilizando Web Deploy e opcionalmente, convertê-los para bancos
de dados completos do SQL Server
Você pode tirar proveito de todos os recursos descritos acima em projetos baseados na ASP.NET Web Forms e ASP.NET MVC.
Download
Você pode habilitar o suporte a ferramentas do SQL CE no VS 2010, primeiramente instalando o VS 2010 SP1 (beta).
Após a instalação do SP1, você também precisa instalar o SQL CE Tools for Visual Studio (Ferramentas do SQL CE para o Visual Studio). Este é um download separado que habilita o suporte a ferramentas do SQL CE dentro VS 2010 SP1.
Passo a passo referente a Dois Cenários
Neste
post eu vou escrever um passo a passo que mostra como você pode tirar
vantagem do SQL CE e do VS 2010 SP1 usando uma aplicação baseada em
ASP.NET Web Forms ou ASP.NET MVC. Especificamente, vamos seguir esse
passos:
- Como criar um banco de dados SQL CE usando o VS
2010 SP1, e então usar o designer do EF4 no Visual Studio para
construir uma camada de modelo a partir dele, e, em seguida, exibir e
editar os dados usando um controle GridView da ASP.NET.
- Como
utilizar uma abordagem de código antecipado (EF Code First) para
definir uma camada de modelo usando classes POCO e depois criar
automaticamente através da biblioteca EF Code-First um banco de dados SQL CE com
base em nossas classes do modelo. Veremos então como podemos usar o
novo suporte do VS 2010 SP1 para o SQL CE para inspecionar o banco de
dados que foi criado, preenchê-lo com dados e, posteriormente, fazer
alterações no esquema dele. Nós faremos tudo isto no contexto de uma
aplicação baseada em ASP.NET MVC.
Você pode acompanhar os dois tutoriais passo a passo a seguir em sua própria máquina instalando o VS 2010 SP1 (beta) e, em seguida, instalando o SQL CE Tools para o Visual Studio (que é um download separado que permite o suporte às ferramentas do SQL CE no VS 2010 SP1).
Passo a Passo 1: Criar um Banco de Dados SQL CE, Criar classes do Modelo do EF, Editar os Dados com um GridView
Este
primeiro passo a passo irá demonstrar como criar e definir um banco de
dados SQL CE dentro de uma aplicação ASP.NET Web Form. Vamos, então,
construir uma camada de modelo do EF para ele e usaremos essa camada do
modelo para habilitar cenários de edição de dados com um controle
<asp:GridView>.
Passo 1: Criar um novo Projeto ASP.NET Web Forms
Vamos
começar usando o comando do menu File->New Project (Arquivo->Novo Projeto) dentro do
Visual Studio para criar um novo projeto ASP.NET Web Forms. Nós vamos
usar a opção de modelo de projeto "ASP.NET Web Application" para que ele
tenha uma skin (formatação) de UI implementada:
Etapa 2: Criar um Banco de Dados SQL CE
Clique
com o botão direito do mouse na pasta "App_Data" dentro do projeto
criado e escolha o comando do menu "Add->New Item"
(Adicionar->Novo Item):
Isso
abrirá a janela de diálogo "Add Item" (Adicionar Item). Selecione o
item "SQL Server Compact 4.0 Local Database" (novo no VS 2010 SP1) e
nomeie o arquivo do banco de dados a ser criado com "Store.sdf":
Note que os arquivos de banco de dados do SQL CE tem uma extensão de arquivo .sdf. Coloque-os dentro da pasta /App_Data da sua aplicação ASP.NET para permitir uma fácil implantação/instalação no servidor.
Quando clicamos no botão "Add" (Adicionar) acima, um arquivo Store.sdf foi adicionado em nosso projeto:
Passo 3: Adicionando uma tabela "Products"
Executando
um duplo clique no arquivo do banco de dados "Store.sdf" abrirá o mesmo
dentro da tab do Server Explorer. Tendo em vista que este é um novo
banco de dados, não há tabelas dentro dele:
Clique
com o botão direito do mouse sobre o ícone "Tables" (Tabelas) e escolha
o comando do menu "Create Table" (Criar Tabela) para criar uma nova
tabela no banco de dados. Chamaremos a nova tabela de "Products" e
adicionaremos 4 colunas nela. Vamos marcar a primeira coluna como uma
chave primária (e a tornaremos uma coluna de identidade (identity) de
forma que seu valor será incrementado automaticamente a cada nova
linha inserida na tabela):
Quando clicarmos em "OK", nossa nova tabela Products será criada no banco de dados SQL CE.
Passo 4: Preencher com Dados
Uma
vez que nossa tabela de produtos está criada, ela irá aparecer no
Server Explorer. Podemos clicar com o botão direito do mouse sobre a
tabela e escolher o comando do menu "Show Table Data" (Mostrar Dados da
Tabela) para editar seus dados:
Vamos adicionar algumas linhas de dados de amostra nela:
Etapa 5: Criar uma Camada de Modelo do EF
Temos
um banco de dados SQL CE com alguns dados nele - vamos agora criar uma
camada de Modelo do EF que irá proporcionar uma maneira para que nós
facilmente possamos consultar/pesquisar e atualizar os dados do banco de
dados.
Vamos clicar com o botão direito sobre o nosso projeto e
escolher o comando do menu "Add->New Item" (Adicionar->Novo
Item). Isso fará com que a janela de diálogo "Add New Item" (Adicionar
Novo Item ) apareça - selecione o item "ADO.NET Entity Data Model"
dentro da janela e o nomeie com "Store.edmx":
Isso
irá adicionar um novo item chamado Store.edmx em nosso Solution
Explorer e iniciará um assistente que nos permite rapidamente criar um
modelo do EF:
Selecione
a opção "Generate From Database" (Gerar a partir do Banco de Dados)
acima e clique em Next (Próximo). Escolha usar o banco de dados SQL CE
Store.sdf que acabamos de criar e clique em Next novamente.
O
assistente irá perguntar a você quais objetos do banco de dados você
deseja importar para o seu modelo. Vamos optar por importar a tabela
"Products" que criamos anteriormente:
Quando
clicamos no botão "Finish" (Finalizar), o Visual Studio irá abrir o
designer do EF. Ele já terá uma entidade Product que mapeia para a
tabela "Products" dentro do nosso banco de dados SQL CE:
O
designer do EF dentro do VS 2010 SP1 funciona exatamente da mesma forma
com o SQL CE como já acontece com o SQL Server Express e SQL Server. A
entidade Product acima será persistida como uma classe (chamada de
"Product") que podemos programaticamente trabalhar dentro de nossa
aplicação ASP.NET.
Passo 6: Compilar o Projeto
Antes
de usar sua camada do modelo, você precisará construir seu projeto. Pressione Ctrl+Shift+B para compilar o projeto, ou use o comando do menu
Build->Build Solution.
Passo 7: Criar uma Página que Usa nossa Camada de Modelo do EF
Vamos
agora criar um simples formulário Web ASP.NET que contém um controle
GridView que podemos usar para exibir e editar os dados de nossos
produtos (através da Camada de Modelo do EF que acabamos de criar).
Clique
com o botão direito do mouse sobre o projeto e escolha o comando
Add->New Item. Selecione o item de template "Web Form from Master
Page" (Web Form a partir de Página Mestra), e dê o nome "Products.aspx"
para a página que você criar. Baseie a master page no template/modelo
"Site.Master" que está localizado na pasta raiz do projeto.
Adicione um cabeçalho <h2>Products</h2> na nova página e adicione um controle <asp:gridview> dentro dela:
Agora
clique na aba "Design" para mudar a visão de design. Selecione o
controle GridView e então clique no canto superior direito dele para
exibir a UI de "Smart Tasks" do GridView:
Escolha
a opção "New Data Source..." (Nova fonte de dados...) no drop down
acima. Isso fará com que a janela de diálogo a seguir apareça, a qual
te permite escolher seu tipo de fonte de dados:
Selecione
a opção de fonte de dados "Entity" (Entidade) - a qual nos permitirá
ligar facilmente o nosso GridView na camada de modelo do EF que criamos
anteriormente. Isso abrirá uma outra janela que nos permite escolher a
nossa camada de modelo:
Selecione
a opção "StoreEntities" no menu suspenso - que é a camada de modelo do
EF que criamos anteriormente. Então clique em Next - o que nos
permitirá escolher qual a entidade dentro dela queremos conectar:
Selecione
a entidade "Products" na janela de diálogo acima - o que indica que
queremos conectar com a classe de entidade "Product" que definimos
anteriormente. Em seguida, clique na caixa de seleção "Enable automatic
updates" (Ativar atualizações automáticas) para garantir que possamos
consultar e atualizar os produtos. Quando você clicar em "Finish", o VS
vai ligar uma <asp:EntityDataSource> em seu controle
<asp:GridView>:
As
dois últimos passos que vamos seguir serão clicar na caixa de seleção
"Enable Editing" (Habilitar Edição) no grid (o que fará com que o Grid
exiba um link "Edit" (Editar) em cada linha) e (opcionalmente) podemos
usar a janela de diálogo Auto Format para escolher um modelo de UI para o
Grid.
Passo 8: Executar a Aplicação
Vamos agora
executar nossa aplicação e navegar até a página /Products.aspx que
contém o nosso GridView. Quando fizermos isso, veremos uma UI de Grid
dos Produtos do nosso banco de dados SQL CE. Clicando no link "Edit" em
qualquer uma das linhas nos permitirá editar seus valores:
Quando
clicamos em "Update" (Atualizar), o GridView irá postar de volta os
valores, persistindo os mesmos através da nossa camada de modelo do EF, e
finalmente os salvará dentro do nosso banco de dados SQL CE.
Aprenda mais sobre como usar o EF com ASP.NET Web Forms
Leia esta série de tutoriais (em Inglês) no site http://asp.net para aprender mais sobre como usar o EF com ASP.NET Web Forms.
A
série de tutoriais usa o SQL Express como banco de dados - mas o bom é
que todos os mesmos passos/conceitos agora também podem ser
feitos/executados com o SQL CE.
Passo a Passo 2: Usando EF Code First com o SQL CE e ASP.NET MVC 3
Nós
usamos uma abordagem de banco de dados em primeiro lugar no exemplo
acima - onde criamos primeiramente o banco de dados, e depois usamos o
designer do EF para criar as classes do modelo a partir do banco de
dados.
Além de suportar um desenvolvimento baseado em um fluxo
de trabalho que utiliza o designer, o EF4 também permite uma opção mais
centrada em código, a qual nós chamamos de Code-First Development ou
"Desenvolvimento de Código Antecipado/Em Primeiro Lugar". O
Desenvolvimento de Código Antecipado permite um fluxo de trabalho de
desenvolvimento muito suave. Esta opção de desenvolvimento te permite:
- Definir
seus objetos do modelo simplesmente escrevendo "plain old classes" POCO
(classes padrão do .NET), sem classes base ou designer visual
necessário.
- Usar uma abordagem de "convenção sobre
configuração", que permite a persistência de dados sem ter que
configurar nada explicitamente
- Opcionalmente, substituir a
persistência baseada em convenção passando a usar uma API de código
fluente para personalizar completamente o mapeamento da persistência
- Opcionalmente
auto-criar um banco de dados com base nas classes do modelo que você
definir - permitindo que você comece primeiramente a partir do código
Já escrevi vários posts no blog sobre a abordagem da biblioteca EF Code First no passado - eu realmente acho que ela é ótima. A boa notícia é que ela também funciona muito bem com o SQL CE.
A
combinação do SQL CE, EF Code First, e o novo suporte das ferramentas
do VS para o SQL CE, permite um fluxo de trabalho bastante agradável. A
seguir está um exemplo simples de como você pode usá-los para construir
uma simples aplicação ASP.NET MVC 3.
Passo 1: Criar um novo Projeto ASP.NET MVC 3
Vamos
começar usando o comando do menu "File->New Project"
(Arquivo->Novo Projeto) dentro do Visual Studio para criar um novo
projeto ASP.NET MVC 3. Nós vamos usar o template/modelo "Internet
Project" (Projeto Internet) para que ele tenha uma formatação de UI
padrão implementada:
Passo 2: Usar o NuGet para Instalar a Biblioteca EFCodeFirst
Em
seguida, vamos usar o gerenciador de pacotes NuGet (instalado
automaticamente pela ASP.NET MVC 3) para adicionar a biblioteca
EFCodeFirst no nosso projeto. Vamos usar o shell de comando do
Gerenciador de Pacotes para fazer isso. Abra o console do gerenciador
de pacotes dentro do Visual Studio selecionando o comando do menu
View->Other Windows->Package Manager Console. Então digite:
install-package EFCodeFirst
dentro
do console do gerenciador de pacotes para fazer o download da
biblioteca EFCodeFirst para que ela seja adicionada em nosso projeto:
Quando entramos com o comando acima, a biblioteca EFCodeFirst será baixada e adicionada em nossa aplicação:
Passo 3: Criar Algumas Classes do Modelo
Usando
um fluxo de trabalho de desenvolvimento baseado na abordagem "code
first" (código em primeiro lugar), criaremos primeiramente nossas classes do modelo (mesmo antes de
termos um banco de dados). Nós criamos essas classes do modelo
escrevendo código.
Para este exemplo, vamos clicar com o botão
direito do mouse sobre a pasta "Models" de nosso projeto e adicionaremos
as três classes a seguir em nosso projeto:
As classes do modelo "Dinner" (Jantar) e "RSVP" acima são simples objetos da CLR (também conhecidos como POCO). Eles não
precisam derivar de qualquer classe base ou implementar qualquer
interface, e as propriedades que expõem são tipos de dados padrão do
.NET. Nenhum atributo de persistência de dados ou código de dados foi
adicionado neles.
A classe "NerdDinners" deriva da classe
DbContext (a qual é fornecida pela biblioteca EFCodeFirst) e trata da
recuperação/persistência de nossas instâncias Dinner e RSVP de/para um
banco de dados.
Passo 4: Listando Jantares
Nós escrevemos todo o código necessário para implementar nossa camada de modelo para este projeto simples.
Vamos agora expor e implementar a URL: /Dinners/Upcoming dentro do nosso projeto. Vamos usá-la para listar jantares programados que acontecerão no futuro.
Nós
vamos fazer isso clicando com o botão direito do mouse em nossa pasta
"Controllers" e selecionando o comando do menu "Add->Controller"
(Adicionar->Controlador). Vamos dar o nome "DinnersController" para o
Controlador que queremos criar. Vamos então implementar um método de
ação chamado "Upcoming" dentro do controlador, o qual lista os jantares
programados usando a nossa camada de modelo acima. Usaremos uma
consulta LINQ para recuperar os dados e passá-los para uma Visão
renderizar os mesmos com o código mostrado a seguir:
Vamos,
então, clicar com o botão direito do mouse dentro do nosso método
Upcoming e escolheremos o comando do menu "Add->View"
(Adicionar->Visão) para criar um template/modelo de visualização
chamado "Upcoming" que exibe nossos jantares. Usaremos a opção de
template "empty" (vazio) na janela de diálogo "Adicionar Visão" e
escreveremos o template de visão a seguir usando o Razor:
Etapa 4: Configurar nosso Projeto para usar um Banco de Dados SQL CE
Terminamos
de escrever todo o nosso código - nosso último passo será configurar
uma string de conexão para usarmos com o banco de dados.
Vamos
apontar nossa classe do modelo NerdDinners para um banco de dados SQL
CE, adicionando a string de conexão <connectionString> a seguir na
parte superior do nosso arquivo web.config:
A
biblioteca EF Code First usa uma convenção padrão onde classes de
contexto buscarão por uma string de conexão que corresponde ao nome da
classe DbContext. Tendo em vista que criamos uma classe "NerdDinners"
anteriormente, nós também nomeamos nossa string de conexão com
"NerdDinners". Acima estamos configurando a nossa string de conexão
para usar o SQL CE como banco de dados, e estamos informando que o nosso
arquivo de banco de dados SQL CE estará localizado dentro do diretório
\App_Data do nosso projeto ASP.NET.
Etapa 5: Executar nossa Aplicação
Agora que construímos nossa aplicação, vamos executá-la!
Nós vamos navegar para a URL /Dinners/Upcoming - fazendo isso, veremos uma uma lista vazia de jantares programados:
Você pode perguntar - mas onde ela pesquisou para obter os jantares? Nós não criamos explicitamente um banco de dados?!?
Um
dos recursos interessantes que a EF Code-First suporta é a capacidade
de criar automaticamente uma banco de dados (com base no esquema das
nossas classes do modelo), quando o banco de dados para o qual as
apontamos ainda não existe. Acima nós configuramos a EF Code-First para
apontar para um banco de dados SQL CE no diretório \App_Data do nosso
projeto. Quando rodamos nossa aplicação, a EF Code-First viu que o
banco de dados SQL CE não existia e o criou automaticamente para nós.
Passo 6: Usando o VS 2010 SP1 para explorar o nosso recém-criado Banco de Dados SQL CE
Clique
no ícone "Show all Files" (Mostrar todos os Arquivos) no Solution
Explorer e você verá o arquivo do banco de dados SQL CE
"NerdDinners.sdf" que foi criado automaticamente para nós pela
biblioteca EF code-first dentro da pasta \App_Data:
Podemos,
opcionalmente, clicar com o botão direito do mouse no arquivo e
selecionar o comando do menu "Include In Project" (Incluir no Projeto)
para adicioná-lo em nossa solução:
Podemos
também executar um duplo clique no arquivo (não importando se ele está
adicionado ao projeto ou não) e o VS 2010 SP1 o abrirá como um banco de
dados que podemos editar dentro da tab "Server Explorer" do IDE.
A
seguir está a visão que temos quando executamos um duplo clique em
nosso arquivo do SQL CE NerdDinners.sdf. Podemos expandí-lo para vermos
o esquema das tabelas Dinners e RSVPs no explorador em formato de
árvore.
Observe como duas tabelas - Dinners e RSVPs - foram
criadas automaticamente para nós dentro do nosso banco de dados SQL CE. Isso foi feito através da EF Code First quando acessamos a classe
NerdDinners ao executarmos a nossa aplicação acima:
Podemos
clicar com o botão direito do mouse sobre uma tabela e usar o comando
"Show Table Data" (Mostrar Dados da Tabela) para entrarmos com os dados
de alguns jantares programados em nosso banco de dados:
Nós vamos usar o editor nativo que o VS 2010 SP1 suporta para preencher os dados da nossa tabela como mostrado a seguir:
E
agora, quando nós pressionarmos o botão "refresh" (atualizar) no
browser em nossa URL /Dinners/Upcoming, vamos ver alguns jantares
programados:
Passo 7: Alterando o nosso Modelo e Esquema do Banco de Dados
Vamos
agora modificar o esquema da nossa camada de modelo e o esquema do
banco de dados, de uma maneira que o novo suporte do VS 2010 SP1 para
ferramentas do SQL CE possa tornar essas modificações mais fáceis de
serem feitas.
Com a EF Code-First você geralmente começa a
fazer alterações no banco de dados, modificando as classes do modelo.
Por exemplo, vamos adicionar uma propriedade adicional do tipo string
chamada "UrlLink" em nossa classe "Dinner". Nós vamos usar essa
propriedade para apontar para um link para mais informações sobre o
evento:
Agora, quando voltarmos a executar o nosso projeto, e visitarmos a URL /Dinners/Upcoming, vamos ver um erro ser lançado:
Estamos
vendo esse erro porque a EF Code-First automaticamente criou nosso
banco de dados e, por padrão quando ela faz isso, ela adiciona uma
tabela que ajuda a controlar se o esquema do nosso banco de dados está
em sincronia com nossas classes do modelo. A EF Code-First
prestativamente lança um erro quando as classes ficam fora de sincronia -
tornando mais fácil rastrear problemas no tempo de desenvolvimento, os
quais você poderia somente encontrar (através de erros obscuros) durante
o tempo de execução. Note que se você não quiser esse recurso, você
pode desativá-lo, alterando as convenções padrão da sua classe DbContext
(neste caso a nossa classe NerdDinners) para que ela não acompanhe a
versão do esquema.
Nossas classes do modelo e o esquema do banco
de dados estão fora de sincronia no exemplo acima - então, como podemos
corrigir isso? Existem duas abordagens que você pode usar hoje:
- Excluir
o banco de dados e deixar que a EF Code-First automaticamente re-crie o
banco de dados com base no novo esquema das classes do modelo (perdendo
os dados existentes no BD)
- Modificar o esquema do banco de
dados existentes para deixá-lo em sincronia com as classes do modelo
(conservando/migrando os dados dentro do BD existente)
Existem
algumas maneiras para que você possa executar a segunda abordagem
acima. A seguir vou mostrar como você pode tirar vantagem do novo
suporte do VS 2010 SP1 para ferramentas do SQL CE, usando uma ferramenta
de esquema do banco de dados para modificar a estrutura do nosso banco
de dados. Nós também vamos suportar um recurso de "migração" com o EF
no futuro, que te permitirá automatizar/scriptar as migrações de banco
de dados programaticamente.
Passo 8: Modificar o Esquema do nosso Banco de Dados SQL CE usando o VS 2010 SP1
O
novo suporte para ferramentas do SQL CE dentro do VS 2010 SP1 torna
mais fácil modificar o esquema do nosso banco de dados SQL CE
existente. Para fazer isso, vamos clicar com o botão direito do mouse
sobre a nossa tabela "Dinners" e escolheremos o comando "Edit Table
Schema" (Editar o Esquema da Tabela):
Isso
fará com que a janela de diálogo a seguir "Edit Table" (Editar Tabela)
apareça. Nós podemos renomear, alterar ou excluir qualquer uma das
colunas existentes em nossa tabela ou clicar na parte inferior da lista
de colunas e digitar para adicionar uma nova coluna. A seguir eu
adicionei uma nova coluna chamada "UrlLink" do tipo "nvarchar" (porque
nossa propriedade é uma string):
Quando
clicamos em OK, nosso banco de dados será atualizado para que ele tenha
a nova coluna e nosso esquema estará em sincronia com as nossas classes
do modelo.
Devido estarmos modificando manualmente o nosso
esquema do banco de dados, há um passo adicional que precisamos executar
para informar a EF Code-First que o esquema do banco de dados está em
sincronia com nossas classes do modelo. Como mencionei anteriormente,
quando um banco de dados é criado automaticamente pela EF Code-First,
ela adiciona uma tabela chamada "EdmMetadata" no banco de dados para
controlar as versões do esquema (e hashear nossas classes do modelo
tendo em vista estas versões do esquema, para detectar mudanças entre as
classes do nosso modelo e o esquema do banco de dados):
Uma
vez que estamos atualizando manualmente e mantendo nosso esquema do
banco de dados, nós não precisamos desta tabela - e podemos simplesmente
excluir a mesma usando o comando do menu "Drop Table":
Isto nos deixará com apenas duas tabelas que correspondem as nossas classes do modelo:
E agora, quando reexecutarmos nossa URL /Dinners/Upcoming, ela mostrará os jantares corretamente:
Um
último toque que poderíamos dar seria atualizar nossa visão para
incluirmos nossa nova propriedade UrlLink e renderizarmos um link
<a> para ela se um evento tiver um link:
E
agora, quando atualizarmos nossa URL /Dinners/Upcoming veremos
hiperlinks para os eventos que têm um UrlLink armazenado no banco de
dados:
Sumário
O
SQL CE fornece um motor de banco de dados gratuito, que pode ser
incluído em sua aplicação e que você pode usar para permitir um fácil
armazenamento de dados. Com o SQL CE 4, você pode agora tirar vantagem
do mesmo dentro de projetos e aplicações ASP.NET (Web Forms e MVC).
O
VS 2010 SP1 oferece suporte a ferramentas que te permitem facilmente
criar, editar e modificar bases de dados SQL CE - bem como usar o
designer padrão do EF com elas. Isso te permite re-usar suas
habilidades e conhecimentos de dados já existentes, aproveitando a opção
de ter um banco de dados incorporado à sua aplicação. Isso é útil
tanto para aplicações de pequeno porte (onde você não precisa da
escalabilidade de um SQL Server completo), bem como para os cenários de
desenvolvimento e teste - onde você quer ser capaz de rapidamente
desenvolver/testar a sua aplicação sem ter uma instância completa de banco
de dados.
O SQL CE torna fácil migrar seus dados mais tarde
para uma instância completa do SQL Server ou SQL Azure se você quiser -
sem ter que alterar o código em sua aplicação. Tudo o que nós
precisaríamos mudar nestes dois cenários apresentados acima é o valor da
<connectionString> dentro do arquivo web.config para que o nosso
código seja executado tendo em vista um servidor SQL Server completo.
Isso proporciona flexibilidade para expandir a sua aplicação de acordo
com o necessário a partir de uma solução de banco de dados incorporada e
pequena.
Espero que ajude,
Scott
P.S. Além do
blog, eu também estou agora utilizando o Twitter para atualizações
rápidas e para compartilhar links.Siga-me em: twitter.com/ScottGu
Texto traduzido do post original por
Leniel Macaferi.
