Usare un database SQLite in un'app UWP
È possibile usare SQLite per archiviare e recuperare i dati in un database leggero nel dispositivo dell'utente. Questa guida illustra come.
Alcuni vantaggi dell'uso di SQLite per l'archiviazione locale
✔️ SQLite è leggero e autonomo. Si tratta di una libreria di codice senza altre dipendenze. Non c'è nulla da configurare.
✔️ Nessun server di database. Il client e il server vengono eseguiti nello stesso processo.
✔️ SQLite si trova nel dominio pubblico in modo che sia possibile usarlo e distribuirlo liberamente con l'app.
✔️ SQLite funziona su 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 compilata da Microsoft.
Entity Framework Core (un framework ORM per la gestione dei database nello sviluppo software)
Entity Framework (EF) è un mapper relazionale a oggetti che è possibile usare per lavorare con 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 di tale codice a un'app UWP e funzionerà con le modifiche appropriate alla stringa di connessione.
Per provare, vedere Introduzione 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 e fornisce un wrapper intuitivo per l'API SQLite nativa di basso livello.
La parte restante di questa guida consente di 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.
Nota
Assicurati di installare il Microsoft.Data.Sqlite' package and not 'Microsoft.Data.Sqlite.Core. Questo pacchetto installerà Microsoft.Data.Sqlite.Core come dipendenza.
Tutte le versioni supportate di Windows supportano SQLite, quindi l'app non deve creare pacchetti di librerie SQLite. L'app può invece usare la versione di SQLite installata con Windows. Questo ti aiuta in alcuni modi.
✔️ Riduce le dimensioni dell'applicazione perché non è necessario scaricare il file binario SQLite e quindi crearne il pacchetto come parte dell'applicazione.
✔️ Impedisce di dover eseguire il push di una nuova versione dell'app agli utenti nel caso in cui SQLite pubblica correzioni critiche per bug e vulnerabilità di sicurezza in SQLite. La versione windows di SQLite viene gestita da Microsoft in coordinamento con SQLite.org.
✔️ Il tempo di caricamento dell'app può essere più veloce perché probabilmente la versione SDK di SQLite verrà già caricata in memoria.
Per iniziare, aggiungere una classe al progetto UWP denominato DataAccess. È possibile usare un progetto di libreria di classi .NET Standard per contenere il codice di accesso ai dati, ma non ne verrà usato uno nell'esempio.
Fare clic con il pulsante destro del mouse sulla soluzione e quindi scegliere Gestisci pacchetti NuGet per la soluzione.
A questo punto, hai una scelta. È possibile usare la versione di SQLite inclusa in Windows o se si ha qualche motivo per usare una versione specifica di SQLite, è possibile includere la libreria SQLite nel pacchetto. Useremo la versione di SQLite inclusa in Windows.
Scegliere la scheda Sfoglia, cercare il pacchetto Microsoft.Data.SQLite.Core e quindi installare la versione stabile più recente.
Aggiungere e recuperare dati in un database SQLite
Queste operazioni verranno eseguite:
1️⃣ Preparare la classe di accesso ai dati.
2️⃣ Inizializzare il database SQLite.
3️⃣ Inserire dati nel database SQLite.
4️⃣ Recuperare 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
Mentre l'esempio inserisce il codice di accesso ai dati in una classe statica, è solo una scelta di progettazione ed è completamente facoltativo.
public static class DataAccess
{
}
Aggiungere le istruzioni using seguenti all'inizio di questo file.
using Microsoft.Data.Sqlite;
using System.Collections.Generic;
Inizializzare il database SQLite
Aggiungere un metodo alla classe DataAccess che inizializza il database 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();
}
}
Questo codice crea il database SQLite e lo archivia nell'archivio dati locale dell'applicazione.
In questo esempio, assegniamo il nome sqlliteSample.db al database, ma è possibile usare qualsiasi nome desiderato purché lo si utilizzi in tutti gli oggetti SqliteConnection di cui si crea 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 inserisce dati nel database SQLite. Questo codice utilizza i parametri nella query per prevenire attacchi di 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}"))
{
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();
}
}
Recuperare dati dal database SQLite
Aggiungere un metodo che ottiene 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 attraverso le righe di dati restituiti. Restituisce true se sono presenti righe lasciate; in caso contrario, restituisce false.
Il metodo GetString
Il parametro ordinale non è importante in questo esempio perché vengono selezionate tutte le voci in una singola colonna. Tuttavia, se più colonne fanno parte della query, usare il valore ordinale per ottenere la colonna da cui eseguire il pull dei dati.
Aggiungere un'interfaccia utente di base
Nel file MainPage.xaml del progetto UWP, aggiungere il seguente 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>
Questa interfaccia utente di base offre all'utente un TextBox che può usare per digitare una stringa che verrà aggiunta al database SQLite. Nell'interfaccia utente, il Button verrà connesso a un gestore eventi che recupererà i dati dal database SQLite e li mostrerà nel ListView.
Nel file MainPage.xaml.cs aggiungere il gestore seguente. Questo è il metodo associato all'evento Click del Button nell'interfaccia utente.
private void AddData(object sender, RoutedEventArgs e)
{
DataAccess.AddData(Input_Box.Text);
Output.ItemsSource = DataAccess.GetData();
}
Si vuole anche assicurarsi che tutti 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();
}
Questo è tutto. Esplorare il Microsoft.Data.Sqlite per vedere quali altre operazioni è possibile eseguire con il database SQLite. Vedi i collegamenti seguenti per informazioni su altri modi per usare i dati nella tua app UWP.
Passaggi successivi
Connettere l'app direttamente a un database di SQL Server
Vedere Usare un database SQL Server in un'app UWP.
Condividere il codice tra app diverse tra piattaforme diverse
Consulta per condividere il codice tra desktop e UWP.