Introdução

Neste post daremos uma introdução ao armazenamento de dados em um banco de dados local. Este tipo de armazenamento de dados é de fundamental importância para dados que vão ser alvo de pesquisas, ordenações e exigem acesso rápido a dado item de um conjunto.

O Windows Phone 8 e 8.1 utilizam o o gerenciador de banco de dados SQL Server Compact Edition, uma versão mais leve e simples do SQL Server utilizado em servidores.  Além do SQL Server CE utilizaremos o LINQ to SQL, uma interface que permite que representemos dados relacionais como objetos sem perder a habilidade de fazer query’s. O LINQ to SQL é dividido em duas partes sendo:

● DataContext: Sua função mais importante é a de servir de fonte de informações. Entre outras funções que serão exploradas em outros tutoriais, a classe DataContext deve ser estendida para a criação do banco de dados local pois a mesma é responsável por fornecer dados.
● Runtime: Interface responsável por traduzir as consultas realizadas para Transact-SQL e fazer a conversão entre dados relacionais e objetos C#.

O banco de dados local do Windows Phone armazena os dados da aplicação em um local conhecido como Isolated Storage. Este local possui este nome pois ele é isolado para a aplicação especifica.

Criando um banco de dados local

Nesta seção mostraremos o exemplo de um banco de dados local que armazena dados de locais para um guia, exemplo semelhante ao do tutorial sobre utilização de Panoramas.

O trecho de código a seguir representa a classe que implementa o banco de dados. Ele trás as tabelas que o banco de dados deve conter e a string responsável pela conexão com o banco de dados local, ou seja, a string que contém o endereço do banco de dados.

[sourcecode language=”csharp” wraplines=”false” collapse=”false”]
namespace PlacesGuide.DataContexts
{
class AppDataBase : DataContext
{
public AppDataBase(string conectionString) : base(conectionString)
{ }
public static string ConectionString
{
get
{
return "isostore:/placesguide.sdf";
}
}
public Table<Place> Places;
public Table<Comment> Comments;
}
}
[/sourcecode]

No trecho acima temos um banco que armazena tabelas de locais e comentários sobre estes locais. Abaixo iremos detalhar a classe Places mostrando os dados que ela contém e as anotações relacionadas ao LINQ. Para funcionar corretamente o LINQ to SQL usa anotações nas classes que representam um dado que deve ser armazenado no SQL Server CE de forma a descrever as tabelas do banco de dados diretamente na classe. Assim as colunas, chaves e outras restrições são representadas diretamente na classe.

[sourcecode language=”csharp” wraplines=”false” collapse=”false”]
namespace PlacesGuide.Models
{
[Table(Name = "Places")]
public class Place
{
[Column(IsPrimaryKey = true, IsDbGenerated = true)]
public int id { get; set; }
[Column]
public string address { get; set; }
[Column]
public int name { get; set; }
[Column]
public string city { get; set; }
[Column]
public string phone { get; set; }
[Column]
public int type { get; set; }
}
}
[/sourcecode]

Outras classes que contenham dados que devem ser armazenados no banco de dados local, tal colo a classe Comments, são descritas exatamente do mesmo jeito.

Usando o banco de dados local

Com o banco de dados criados já podemos usar o mesmo.

Antes de tudo deve se instanciar o banco de dados na aplicação para o mesmo ficar disponível. Para fazer isso criaremos um método CreateDB que será chamado no método construtor da aplicação.

[sourcecode language=”csharp” wraplines=”false” collapse=”false”]
private void CreateDB()
{
using (AppDataBase db = new AppDataBase(AppDataBase.ConectionString))
{
if (!db.DatabaseExists())
{
db.CreateDatabase();
}
}
}
[/sourcecode]

A chamada a este método deve ser adicionada ao construtor da classe, geralmente no arquivo denominado nome_d0_projeto.xaml.cs.

A inserção de dados do banco de dados é feita diretamente com os objetos C# através do método InserOnSubmit e SubmitChanges como no trecho de código a seguir.

[sourcecode language=”csharp” wraplines=”false” collapse=”false”]
Place place = new Place();
// Prencha os dados do place.

using (AppDataBase db = new AppDataBase(AppDataBase.ConectionString))
{
db.Places.InsertOnSubmit(place);
db.SubmitChanges();
}
[/sourcecode]

Caso seja uma sequência de inserções o SubmitChanges deve ser chamado somente ao final, assim ele fara a inserção de todos os dados em uma unica operação.

Agora que já fizemos a inserção de dados no banco de dado local podemos consultar o mesmo. Essa consulta é feita através de uma consulta SQL comum, porém o runtime do LINQ devolverá o resultado como um objeto C#. Assim, uma consulta que retorne todos os locais armazenados no aplicativo pode ser implementada da seguinte forma:

[sourcecode language=”csharp” wraplines=”false” collapse=”false”]
AppDataBase db = new AppDataBase(AppDataBase.ConectionString);
var _onDbPlaces = (from Place place in db.Places select new PlaceViewModel
{
Id = place.id,
Name = place.name,
Address = place.address,
City = place.city,
Phone = place.phone,
Type = place.type
}).ToList();
[/sourcecode]

O trecho de código acima é responsável por consultar todos os places armazenados e já converter o mesmo em objetos C# organizador em uma lista.
Com isso já podemos fazer todas as operações esperados em um banco de dados local só variando a query SQL. Além disto a classe DataContext provê outros métodos que, se bem explorados, podem facilitar ainda mais a manipulação do banco de dados local.