Usare un database SQLite in un'app UWP
Puoi usare SQLite per archiviare e recuperare dati in un database leggero nel dispositivo dell'utente. Questa guida ti mostra come procedere.
Alcuni vantaggi dell'uso di SQLite per l'archiviazione locale
✔️ SQLite è leggero e indipendente. È una libreria di codice senza altre dipendenze. Non richiede alcuna configurazione.
✔️ Nessun server di database. Il client e il server vengono eseguiti nello stesso processo.
✔️ SQLite è di dominio pubblico e può essere usato e distribuito liberamente con la propria app.
✔️ SQLite funziona su tutte le piattaforme e architetture.
Altre informazioni su SQLite sono disponibili qui.
Scegliere un livello di astrazione
È consigliabile usare Entity Framework Core o la libreria SQLite open source creata da Microsoft.
Entity Framework Core
Entity Framework (EF) è un mapper relazionale a oggetti che ti consente di gestire dati relazionali usando oggetti specifici del dominio. Se hai già usato questo framework per lavorare con i dati in altre app .NET, puoi eseguire la migrazione del relativo codice a un'app UWP. Sarà sufficiente apportate le modifiche appropriate alla stringa di connessione.
Per provarlo vedi Guida introduttiva a EF Core.
Libreria SQLite
La libreria Microsoft.Data.Sqlite implementa le interfacce nello spazio dei nomi System.Data.Common. Microsoft gestisce attivamente queste implementazioni, che offrono un wrapper intuitivo per l'API SQLite nativa di basso livello.
Il resto di questa guida ti mostra come usare questa libreria.
Configurare la soluzione per l'uso della libreria Microsoft.Data.SQlite
Inizieremo con un progetto UWP di base e quindi installeremo i pacchetti NuGet appropriati.
Tutte le versioni supportate di Windows supportano SQLite, per cui non è necessario che l'applicazione inserisca nel pacchetto le librerie SQLite. L'app potrà invece usare la versione di SQLite installata con Windows. Ciò presenta vari vantaggi.
✔️ Riduce le dimensioni dell'applicazione, poiché non è necessario scaricare il file binario di SQLite e creare il pacchetto come parte dell'applicazione.
✔️ Consente di evitare di eseguire il push di una nuova versione dell’app agli utenti nel caso in cui SQLite pubblichi correzioni critiche di bug e vulnerabilità di sicurezza in SQLite. La versione Windows di SQLite è gestita da Microsoft in collaborazione con SQLite.org.
✔️ Il tempo di caricamento dell'app può essere ridotto perché molto probabilmente la versione dell'SDK di SQLite sarà già caricata in memoria.
Iniziamo aggiungendo al progetto UWP una classe denominata DataAccess. È possibile utilizzare un progetto di libreria di classi .NET Standard per contenere il codice di accesso ai dati, ma nel nostro esempio non ne utilizzeremo uno.
Fai clic con il pulsante destro del mouse sulla soluzione e quindi scegli Gestisci pacchetti NuGet per la soluzione.
A questo punto puoi procedere in due modi. Puoi usare la versione di SQLite inclusa in Windows oppure, se per qualche motivo è opportuno usare una versione specifica di SQLite, puoi includere la libreria SQLite nel pacchetto. Useremo la versione di SQLite inclusa in Windows.
Scegli la scheda Sfoglia, cercare il pacchetto Microsoft.Data.SQLite.Core, quindi installare la versione stabile più recente.
Aggiungere e recuperare dati in un database SQLite
Eseguiremo queste operazioni:
1️⃣ Preparare la classe di accesso ai dati.
2️⃣ Inizializzare il database SQLite.
3️⃣ Inserire i dati nel database SQLite.
4️⃣ Recuperare i dati dal database SQLite.
5️⃣ Aggiungere un'interfaccia utente di base.
Preparare la classe di accesso ai dati
Aprire la classe DataAccess nel progetto e renderla statica.
Nota
Il nostro esempio inserirà il codice di accesso ai dati in una classe statica, ma è una scelta di progettazione totalmente facoltativa.
public static class DataAccess
{
}
Aggiungi le istruzioni using seguenti all'inizio di questo file.
using Microsoft.Data.Sqlite;
using System.Collections.Generic;
Inizializzare il database SQLite
Aggiungi un metodo per inizializzare il database SQLite alla classe DataAccess.
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();
}
}
Questo codice crea il database SQLite e lo archivia nell'archivio dati locali dell'applicazione.
In questo esempio denominiamo il database sqlliteSample.db, ma puoi scegliere qualsiasi altro nome a condizione che tale nome venga usato in tutti gli oggetti SqliteConnection di cui crei un'istanza.
Nel costruttore del file App.xaml.cs del progetto UWP chiama il metodo InitializeDatabase della classe DataAccess.
public App()
{
this.InitializeComponent();
this.Suspending += OnSuspending;
DataAccess.InitializeDatabase();
}
Inserire dati nel database SQLite
Aggiungere un metodo alla classe DataAccess che inserisca i dati nel database SQLite. Questo codice usa i parametri della query per impedire attacchi SQL injection.
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();
}
}
Recuperare dati dal database SQLite
Aggiungi un metodo per ottenere le righe di dati da un database 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;
}
Il metodo Read procede scorrendo le righe dei dati restituiti. Restituisce true se rimangono delle righe, altrimenti restituisce false.
Il metodo GetString restituisce il valore della colonna specificata come stringa. Il metodo accetta un valore intero che rappresenta l'ordinale di colonna in base zero dei dati desiderati. Puoi usare metodi simili, ad esempio GetDataTime e GetBoolean. Scegli un metodo in base al tipo di dati contenuto nella colonna.
Il parametro dell'ordinale non è importante in questo esempio perché selezioniamo tutte le voci di una singola colonna. Se la query include più colonne, tuttavia, usa il valore dell'ordinale per ottenere la colonna da cui vuoi recuperare i dati.
Aggiungere un'interfaccia utente di base
Nel file MainPage.xaml del progetto UWP aggiungi il codice XAML seguente.
<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>
Questa interfaccia utente di base offre un controllo TextBox che l'utente può usare per digitare una stringa che verrà aggiunta al database SQLite. Connetteremo il controllo Button dell'interfaccia utente a un gestore eventi che recupererà i dati dal database SQLite e li visualizzerà in ListView.
Nel file MainPage.xaml.cs aggiungi il gestore seguente. Questo è il metodo che abbiamo associato all'evento Click di Button nell'interfaccia utente.
private void AddData(object sender, RoutedEventArgs e)
{
DataAccess.AddData(Input_Box.Text);
Output.ItemsSource = DataAccess.GetData();
}
Si vuole essere certi che i dati esistenti vengano caricati all'avvio dell'applicazione. Aggiungere una riga di codice al costruttore MainPage per chiamare GetData().
public MainPage()
{
this.InitializeComponent();
Output.ItemsSource = DataAccess.GetData();
}
È tutto. Esplora Microsoft.Data.Sqlite per scoprire cos'altro puoi fare con il database SQLite. Visita i collegamenti riportati di seguito per scoprire altri modi per usare i dati nella tua app UWP.
Passaggi successivi
Connettere l'app direttamente a un database di SQL Server
Vedi Usare un database SQL Server in un'app UWP.
Condividere codice tra app diverse in piattaforme diverse
Vedi Condividere codice tra un'app desktop e un'app UWP.