Usar um banco de dados SQLite em um aplicativo UWP

Você pode usar o SQLite para armazenar e recuperar dados em um banco de dados leve no dispositivo do usuário. Este guia mostra como.

Alguns benefícios do uso do SQLite para armazenamento local

✔️ O SQLite é leve e autossuficiente. É uma biblioteca de códigos sem nenhuma outra dependência. Não há nada para configurar.

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

✔️ O SQLite está no domínio público para que você possa usá-lo e distribuí-lo livremente com seu aplicativo.

✔️ O SQLite funciona entre plataformas e arquiteturas.

Você pode ler mais sobre o SQLite aqui.

Escolher uma camada de abstração

Recomendamos que você use o Entity Framework Core ou a biblioteca SQLite de software livre criada pela Microsoft.

Entity Framework Core

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

Para experimentar, consulte Introdução ao 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 nativa de baixo nível do SQLite.

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

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

Começaremos com um projeto UWP básico e, em seguida, instalaremos os pacotes Nuget apropriados.

Nota

Certifique-se de instalar o Microsoft.Data.Sqlite' package and not 'Microsoft.Data.Sqlite.Core. Esse pacote instalará Microsoft.Data.Sqlite.Core como uma dependência.

Todas as versões com suporte do Windows dão suporte ao SQLite, portanto, seu aplicativo não precisa empacotar bibliotecas SQLite. Em vez disso, seu aplicativo pode usar a versão do SQLite que vem instalada com o Windows. Isso ajuda você de algumas maneiras.

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

✔️ Impede que você precise enviar uma nova versão do aplicativo para os usuários caso o SQLite publique correções críticas em bugs e vulnerabilidades de segurança no SQLite. A versão do Windows do SQLite é mantida pela Microsoft em coordenação com 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 seu projeto UWP chamado DataAccess. Você pode usar um projeto de biblioteca de classes do .NET Standard para conter seu código de acesso a dados, mas não usaremos um em nosso 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 escolha. Você pode usar a versão do SQLite incluída no Windows ou, se tiver algum motivo para usar uma versão específica do SQLite, poderá incluir a biblioteca SQLite em seu 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 SQLite

Faremos estas coisas:

1️⃣ Preparar a classe de acesso a dados.

2️⃣ Inicializar o banco de dados SQLite.

3️⃣ Inserir dados no banco de dados SQLite.

4️⃣ Recuperar dados do banco de dados SQLite.

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

Preparar a classe de acesso a dados

Abra a classe DataAccess em seu projeto e torne essa classe estática.

Nota

Embora nosso exemplo coloque o código de acesso a dados em uma classe estática, ele é apenas uma opção de design e é completamente 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 inicializa 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();
    }
}

Esse 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 desejado, desde que use esse nome em todos os objetos SqliteConnection instanciados.

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 SQLite

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

public static void AddData(string inputText)
{
    string dbpath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "sqliteSample.db");
    using (SqliteConnection db =
      new SqliteConnection($"Filename={dbpath}"))
    {
        SQLitePCL.Batteries.Init();
        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 obtém 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 Read avança pelas linhas de dados retornados. Ele retornará true se houver 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 de coluna baseado em zero dos dados desejados. Você pode usar métodos semelhantes, como GetDataTime e GetBoolean. Escolha um método com base em que 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 consulta, use o valor ordinal para obter a coluna da qual você deseja extrair dados.

Adicionar uma interface básica do usuário

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

<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 básica do usuário fornece ao usuário um TextBox que ele pode usar 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 mostraremos esses dados no ListView.

No arquivo MainPage.xaml.cs, adicione o manipulador a seguir. 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 são carregados quando o aplicativo é iniciado. Adicione uma linha de código ao construtor MainPage para chamar GetData().

public MainPage()
{
    this.InitializeComponent();

    Output.ItemsSource = DataAccess.GetData();
}

É isso mesmo. Explore o Microsoft.Data.Sqlite para ver quais outras coisas você pode fazer com seu banco de dados SQLite. Confira os links abaixo 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

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

Compartilhar código entre diferentes aplicativos 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

Consulte o exemplo de banco de dados de pedidos de clientes .