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

✔️ SQLite é leve e independente. É uma biblioteca de códigos sem outras dependências. Não há nada para configurar.

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

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

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

Você pode ler mais sobre SQLite aqui.

Escolha uma camada de abstração

Recomendamos que você use o Entity Framework Core ou a biblioteca SQLite de código aberto criada pela Microsoft.

Núcleo do Entity Framework

O Entity Framework (EF) é um mapeador objeto-relacional 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 as alterações apropriadas na cadeia de conexão.

Para experimentá-lo, consulte Introdução ao EF Core.

Biblioteca SQLite

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

O resto deste guia ajuda-o a utilizar esta biblioteca.

Configure 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.

Observação

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

Todas as versões suportadas do Windows suportam 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. Isto ajuda-o de algumas formas.

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

✔️ Evita que você tenha que enviar uma nova versão do seu aplicativo para os usuários caso o SQLite publique 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 a SQLite.org.

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

Vamos começar adicionando uma classe ao seu projeto UWP chamada DataAccess. Você pode usar um projeto de biblioteca de classes .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 rato na solução e, em seguida, clique em Gerir Pacotes NuGet para a 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 que está incluída no Windows.

Escolha a guia Procurar, procure pelo pacote Microsoft.Data.SQLite.Core e, em seguida, instale a versão estável mais recente.

Adicionar e recuperar dados em um banco de dados SQLite

Faremos o seguinte:

1️⃣ Preparar a classe de acesso aos dados.

2️⃣ Inicialize o banco de dados SQLite.

3️⃣ Insira dados no banco de dados SQLite.

4️⃣ Recuperar dados do banco de dados SQLite.

5️⃣ Adicione uma interface de usuário básica.

Preparar a classe de acesso a dados

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

Observação

Embora nosso exemplo coloque o código de acesso a dados em uma classe estática, é apenas uma escolha de design e é completamente opcional.

public static class DataAccess
{

}

Adicione as seguintes instruções using à parte superior deste ficheiro.

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 o nome que quiser, desde que use esse nome em todos os objetos SqliteConnection que você instanciar.

No construtor do arquivo App.xaml.cs do seu 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 retorna true se houver linhas restantes, caso contrário, ele retorna false.

O GetString método 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 no tipo de dados que 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 de 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 de usuário básica dá ao usuário uma TextBox que ele pode usar para digitar uma cadeia de caracteres que adicionaremos ao banco de dados SQLite. Conectaremos o Button nesta 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 de utilizador.

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 serão 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. Explore o Microsoft.Data.Sqlite para ver o que 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óximos passos

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.

Partilhe código entre diferentes aplicações em diferentes plataformas

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

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

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