Använda en SQLite-databas i en UWP-app
Du kan använda SQLite för att lagra och hämta data i en lätt databas på användarens enhet. Den här guiden visar hur.
Vissa fördelar med att använda SQLite för lokal lagring
✔️ SQLite är lättvikt och fristående. Det är ett kodbibliotek utan andra beroenden. Det finns inget att konfigurera.
✔️ Det finns ingen databasserver. Klienten och servern körs i samma process.
✔️ SQLite finns i den offentliga domänen så att du fritt kan använda och distribuera den med din app.
✔️ SQLite fungerar på olika plattformar och arkitekturer.
Du kan läsa mer om SQLite här.
Välj ett abstraktionslager
Vi rekommenderar att du använder antingen Entity Framework Core eller SQLite-bibliotek med öppen källkod som skapats av Microsoft.
Entity Framework Core
Entity Framework (EF) är en objektrelationsmappare som du kan använda för att arbeta med relationsdata med hjälp av domänspecifika objekt. Om du redan har använt det här ramverket för att arbeta med data i andra .NET-appar kan du migrera koden till en UWP-app och den fungerar med lämpliga ändringar i anslutningssträngen.
Om du vill prova kan du läsa Komma igång med EF Core.
SQLite-bibliotek
Biblioteket Microsoft.Data.Sqlite implementerar gränssnitten i namnområdet System.Data.Common. Microsoft underhåller aktivt dessa implementeringar, och de tillhandahåller en intuitiv omslutning kring det inbyggda SQLite-API:et på låg nivå.
Resten av den här guiden hjälper dig att använda det här biblioteket.
Konfigurera din lösning så att den använder Microsoft.Data.SQlite-biblioteket
Vi börjar med ett grundläggande UWP-projekt och installerar sedan lämpliga Nuget-paket.
Not
Kontrollera att du installerar Microsoft.Data.Sqlite' package and not 'Microsoft.Data.Sqlite.Core. Det här paketet installerar Microsoft.Data.Sqlite.Core som ett beroende.
Alla versioner av Windows stöder SQLite, så din app behöver inte paketera SQLite-bibliotek. I stället kan din app använda den version av SQLite som installeras med Windows. Detta hjälper dig på några sätt.
✔️ Minskar storleken på ditt program eftersom du inte behöver ladda ned SQLite-binärfilen och sedan paketera den som en del av ditt program.
✔️ Hindrar dig från att behöva skicka en ny version av appen till användare om SQLite publicerar kritiska korrigeringar av buggar och säkerhetsrisker i SQLite. Windows-versionen av SQLite underhålls av Microsoft i samarbete med SQLite.org.
✔️ Appinläsningstiden kan gå snabbare eftersom SDK-versionen av SQLite förmodligen redan kommer att läsas in i minnet.
Vi börjar med att lägga till en klass i ditt UWP-projekt med namnet DataAccess. Du kan använda ett .NET Standard-klassbiblioteksprojekt för att innehålla din dataåtkomstkod, men vi använder inte något i vårt exempel.
Högerklicka på lösningen och klicka sedan på Hantera NuGet-paket för lösning.
Nu har du ett val. Du kan använda den version av SQLite som ingår i Windows eller om du har någon anledning att använda en specifik version av SQLite kan du inkludera SQLite-biblioteket i paketet. Vi kommer att använda den version av SQLite som ingår i Windows.
Välj fliken Bläddra, sök efter paketet Microsoft.Data.SQLite.Core och installera sedan den senaste stabila versionen.
Lägga till och hämta data i en SQLite-databas
Vi gör följande:
1️⃣ Förbered dataåtkomstklassen.
2️⃣ Initiera SQLite-databasen.
3️⃣ Infoga data i SQLite-databasen.
4️⃣ Hämta data från SQLite-databasen.
5️⃣ Lägg till ett grundläggande användargränssnitt.
Förbereda dataåtkomstklassen
Öppna klassen DataAccess i projektet och gör klassen statisk.
Not
Vårt exempel placerar dataåtkomstkod i en statisk klass, men det är bara ett designval och är helt valfritt.
public static class DataAccess
{
}
Lägg till följande using-instruktioner överst i den här filen.
using Microsoft.Data.Sqlite;
using System.Collections.Generic;
Initiera SQLite-databasen
Lägg till en metod i klassen DataAccess som initierar SQLite-databasen.
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();
}
}
Den här koden skapar SQLite-databasen och lagrar den i programmets lokala datalager.
I det här exemplet namnger vi databasen sqlliteSample.db men du kan använda det namn du vill så länge du använder det namnet i alla SqliteConnection objekt som du instansierar.
Anropa InitializeDatabase-metoden för klassen DataAccess i konstruktorn för App.xaml.cs-filen i ditt UWP-projekt.
public App()
{
this.InitializeComponent();
this.Suspending += OnSuspending;
DataAccess.InitializeDatabase();
}
Infoga data i SQLite-databasen
Lägg till en metod i klassen DataAccess som infogar data i SQLite-databasen. Den här koden använder parametrar i frågan för att förhindra SQL-inmatningsattacker.
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();
}
}
Hämta data från SQLite-databasen
Lägg till en metod som hämtar rader med data från en SQLite-databas.
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;
}
Metoden Read avancerar genom raderna med returnerade data. Den returnerar true om det finns rader kvar, annars returneras false.
Metoden GetString returnerar värdet för den angivna kolumnen som en sträng. Det accepterar ett heltalsvärde som representerar den nollbaserade kolumnordningen för de data som du vill använda. Du kan använda liknande metoder som GetDataTime och GetBoolean. Välj en metod baserat på vilken typ av data kolumnen innehåller.
Ordningsparametern är inte lika viktig i det här exemplet eftersom vi väljer alla poster i en enskild kolumn. Men om flera kolumner är en del av din fråga använder du ordningstalet för att hämta den kolumn som du vill hämta data från.
Lägga till ett grundläggande användargränssnitt
Lägg till följande XAML i MainPage.xaml- fil för UWP-projektet.
<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>
Det här grundläggande användargränssnittet ger användaren en TextBox som de kan använda för att skriva en sträng som vi ska lägga till i SQLite-databasen. Vi ansluter Button i det här användargränssnittet till en händelsehanterare som hämtar data från SQLite-databasen och sedan visar dessa data i ListView.
Lägg till följande hanterare i filen MainPage.xaml.cs. Det här är den metod som vi associerade med händelsen Click i Button i användargränssnittet.
private void AddData(object sender, RoutedEventArgs e)
{
DataAccess.AddData(Input_Box.Text);
Output.ItemsSource = DataAccess.GetData();
}
Vi vill också vara säkra på att alla befintliga data läses in när programmet startar. Lägg till en kodrad i MainPage konstruktorn för att anropa GetData().
public MainPage()
{
this.InitializeComponent();
Output.ItemsSource = DataAccess.GetData();
}
Det var allt. Utforska Microsoft.Data.Sqlite för att se vad andra saker du kan göra med din SQLite-databas. Kolla in länkarna nedan för att lära dig mer om andra sätt att använda data i din UWP-app.
Nästa steg
Ansluta din app direkt till en SQL Server-databas
Se Använda en SQL Server-databas i en UWP-app.
Dela kod mellan olika appar på olika plattformar
Se Dela kod mellan skrivbordet och UWP.