Usar um banco de dados do SQLite em um aplicativo UWP

É possível usar o SQLite para armazenar e recuperar dados em um banco de dados leve no dispositivo do usuário. Este guia mostra como fazer isso.

Alguns benefícios do uso do SQLite para armazenamento local

✔️ O SQLite é leve e autossuficiente. É uma biblioteca de código sem nenhuma outra dependência. Não há nada a ser configurado.

✔️ Não há nenhum servidor de banco de dados. O cliente e o servidor são executados no mesmo processo.

✔️ O SQLite é de domínio público, então você pode usá-lo livremente e distribuí-lo com seu aplicativo.

✔️ O SQLite funciona em várias arquiteturas e plataformas.

Você pode ler mais sobre o SQLite aqui.

Escolher uma camada de abstração

Recomendamos usar o Entity Framework Core ou a biblioteca SQLite open-source criada pela Microsoft.

Entity Framework Core

O EF (Entity Framework) é um mapeador relacional de objeto que pode ser usado para trabalhar com os dados relacionais usando objetos específicos de domínio. Caso já tenha usado essa estrutura para trabalhar com os dados em outros aplicativos .NET, poderá migrar esse código para um aplicativo UWP e ele funcionará com as alterações apropriadas feitas na cadeia de conexão.

Para experimentar, confira Introdução com EF Core.

Biblioteca SQLite

A biblioteca Microsoft.Data.Sqlite implementa as interfaces no namespace System.Data.Common. A Microsoft mantém ativamente essas implementações e elas fornecem um wrapper intuitivo em torno da API do SQLite nativo de baixo nível.

O restante deste guia ajuda você a usar essa biblioteca.

Configurar sua solução para usar a biblioteca Microsoft.Data.SQlite

Vamos começar com um projeto UWP básico e depois instalar os pacotes NuGet certos.

Todas as versões com suporte do Windows são compatíveis com o SQLite, portanto, o aplicativo não precisa empacotar bibliotecas SQLite. Em vez disso, o aplicativo pode usar a versão do SQLite que vem instalado com o Windows. Isso ajuda você de algumas maneiras.

✔️ Reduz o tamanho do aplicativo, pois você não precisa baixar o binário do SQLite e empacotá-lo como parte do aplicativo.

✔️ Impede que você precise efetuar push de uma nova versão do aplicativo para os usuários no caso de a SQLite publicar correções críticas para bugs e vulnerabilidades de segurança no SQLite. A versão Windows do SQLite é mantida pela Microsoft em coordenação com o SQLite.org.

✔️ O tempo de carregamento do aplicativo tem o potencial de ser mais rápido porque, provavelmente, a versão do SDK do SQLite já será carregada na memória.

Vamos começar adicionando uma classe ao projeto UWP chamada DataAccess. Você pode usar um projeto de biblioteca de classes do .NET Standard para conter o código de acesso a dados, mas não o usaremos no exemplo.

Clique com o botão direito do mouse na solução e clique em Gerenciar pacotes NuGet para solução.

Neste ponto, você tem uma opção. É possível usar a versão do SQLite incluída no Windows ou, se você tiver algum motivo para usar uma versão específica do SQLite, você pode incluir a biblioteca SQLite no pacote. Vamos usar a versão do SQLite incluída no Windows.

Escolha a guia Procurar, procure o pacote Microsoft.Data.SQLite.core e instale a última versão instável.

Adicionar e recuperar dados em um banco de dados do SQLite

Vamos fazer o seguinte:

1️⃣ Preparar a classe de acesso a dados.

2️⃣ Inicializar o banco de dados SQLite.

3️⃣ Inserir dados no banco de dados do SQLite.

4️⃣ Recuperar dados do banco de dados SQLite.

5️⃣ Adicionar uma interface do usuário básico.

Preparar a classe de acesso a dados

Abra a classe DataAccess no projeto e faça com que ela seja estática.

Observação

Embora nosso exemplo coloque o código de acesso a dados em uma classe estática, isso é somente uma opção de design e é totalmente opcional.

public static class DataAccess
{

}

Adicione a instrução a seguir na parte superior deste arquivo.

using Microsoft.Data.Sqlite;
using System.Collections.Generic;

Inicializar o banco de dados SQLite

Adicione um método à classe DataAccess que inicialize o banco de dados SQLite.

public async static void InitializeDatabase()
{ 
     await ApplicationData.Current.LocalFolder.CreateFileAsync("sqliteSample.db", CreationCollisionOption.OpenIfExists);
     string dbpath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "sqliteSample.db");
     using (SqliteConnection db =
        new SqliteConnection($"Filename={dbpath}"))
    {
        db.Open();

        String tableCommand = "CREATE TABLE IF NOT " +
            "EXISTS MyTable (Primary_Key INTEGER PRIMARY KEY, " +
            "Text_Entry NVARCHAR(2048) NULL)";

        SqliteCommand createTable = new SqliteCommand(tableCommand, db);

        createTable.ExecuteReader();
    }
}

Este código cria o banco de dados SQLite e o armazena no armazenamento de dados local do aplicativo.

Neste exemplo, nomeamos o banco de dados sqlliteSample.db, mas você pode usar qualquer nome que desejar, desde que use esse nome em todos os objetos SqliteConnection em que criar uma instância.

No construtor do arquivo App.xaml.cs do projeto UWP, chame o método InitializeDatabase da classe DataAccess.

public App()
{
    this.InitializeComponent();
    this.Suspending += OnSuspending;

    DataAccess.InitializeDatabase();
}

Inserir dados no banco de dados do SQLite

Adicione um método à classe DataAccess que insira dados no banco de dados SQLite. Este código usa parâmetros na consulta para evitar ataques de injeção do SQL.

public static void AddData(string inputText)
{
    string dbpath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "sqliteSample.db");
    using (SqliteConnection db =
      new SqliteConnection($"Filename={dbpath}"))
    {
        db.Open();

        SqliteCommand insertCommand = new SqliteCommand();
        insertCommand.Connection = db;

        // Use parameterized query to prevent SQL injection attacks
        insertCommand.CommandText = "INSERT INTO MyTable VALUES (NULL, @Entry);";
        insertCommand.Parameters.AddWithValue("@Entry", inputText);

        insertCommand.ExecuteReader();
    }

}

Recuperar dados do banco de dados SQLite

Adicione um método que obtenha linhas de dados de um banco de dados SQLite.

public static List<String> GetData()
{
    List<String> entries = new List<string>();

   string dbpath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "sqliteSample.db");
   using (SqliteConnection db =
      new SqliteConnection($"Filename={dbpath}"))
    {
        db.Open();

        SqliteCommand selectCommand = new SqliteCommand
            ("SELECT Text_Entry from MyTable", db);

        SqliteDataReader query = selectCommand.ExecuteReader();

        while (query.Read())
        {
            entries.Add(query.GetString(0));
        }
    }

    return entries;
}

O método Leitura avança por linhas de dados retornados. Ele retornará true se houver mais linhas restantes; caso contrário, retornará false.

O método GetString retorna o valor da coluna especificada como uma cadeia de caracteres. Ele aceita um valor inteiro que representa o ordinal da coluna baseada em zero dos dados que você deseja. Você pode usar métodos semelhantes, como GetDataTime e GetBoolean. Escolha um método com base em qual tipo de dados a coluna contém.

O parâmetro ordinal não é tão importante neste exemplo porque estamos selecionando todas as entradas em uma única coluna. No entanto, se várias colunas fizerem parte da sua consulta, use o valor ordinal para obter a coluna da qual você deseja obter dados.

Adicionar uma interface do usuário básica

No arquivo MainPage.xaml do projeto UWP, adicione o seguinte XAML.

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
    <StackPanel>
        <TextBox Name="Input_Box"></TextBox>
        <Button Click="AddData">Add</Button>
        <ListView Name="Output">
            <ListView.ItemTemplate>
                <DataTemplate>
                    <TextBlock Text="{Binding}"/>
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>
    </StackPanel>
</Grid>

Essa interface do usuário básica dá ao usuário um TextBox que pode ser usado para digitar uma cadeia de caracteres que adicionaremos ao banco de dados SQLite. Conectaremos o Button nessa interface do usuário a um manipulador de eventos que recuperará dados do banco de dados SQLite e, em seguida, mostrará esses dados no ListView.

No arquivo MainPage.xaml.cs, adicione o seguinte manipulador. Este é o método que associamos ao evento Click do Button na interface do usuário.

private void AddData(object sender, RoutedEventArgs e)
{
    DataAccess.AddData(Input_Box.Text);

    Output.ItemsSource = DataAccess.GetData();
}

Também queremos ter certeza de que todos os dados existentes sejam carregados quando o aplicativo for iniciado. Adicione uma linha de código ao construtor MainPage para chamar GetData().

public MainPage()
{
    this.InitializeComponent();

    Output.ItemsSource = DataAccess.GetData();
}

Isso é tudo. Explore o Microsoft.Data.Sqlite para ver o que mais você pode fazer com o banco de dados SQLite. Confira os links a seguir para saber mais sobre outras maneiras de usar dados em seu aplicativo UWP.

Próximas etapas

Conectar seu aplicativo diretamente a um banco de dados do SQL Server

Veja Usar um banco de dados do SQL Server em um aplicativo UWP.

Compartilhar código entre aplicativos diferentes em diferentes plataformas

Confira Compartilhar código entre a área de trabalho e a UWP.

Adicionar páginas de detalhes mestre com back-ends Azure SQL

Confira Exemplo de banco de dados de pedidos do cliente.