Självstudie: Använda en SQLite-databas i en Windows-app

SQLite är en tillförlitlig, enkel databaslösning för lagring av data lokalt i Windows appar. Till skillnad från traditionella databassystem som kräver separata serverinstallationer och komplexa konfigurationer körs SQLite helt i programprocessen och lagrar data i en enda fil på användarens enhet.

Den här självstudien visar hur du integrerar SQLite i ditt WinUI-program med hjälp av Microsofts rekommenderade dataåtkomstbibliotek. Du lär dig hur du konfigurerar en databas, skapar tabeller och implementerar grundläggande dataåtgärder – samtidigt som du följer rekommenderade säkerhetsmetoder för att skydda mot vanliga säkerhetsrisker.

Vad du ska åstadkomma

I den här självstudien får du lära dig att:

  • Konfigurera din Windows app för att använda SQLite med Microsoft.Data.SQLite-biblioteket
  • Skapa och initiera en lokal databas
  • Implementera metoder för säker datainfogning och hämtning
  • Skapa ett enkelt användargränssnitt för att interagera med dina data

Förutsättningar

För att slutföra denna handledning behöver du:

  • Visual Studio 2026 eller senare med WinUI-programutvecklingsarbetsbelastning
  • Grundläggande kunskaper om C# och XAML
  • Förstå grundläggande databasbegrepp

Viktiga förbättringar som den här metoden erbjuder

Det finns flera fördelar med att använda SQLite för lokal datalagring i din Windows app:

  • Förenklad distribution: Ingen separat databasserverinstallation krävs
  • Förbättrad säkerhet: Data förblir lokala på användarens enhet
  • Förbättrad prestanda: Direkt filåtkomst eliminerar nätverksfördröjning
  • Minskad komplexitet: Enkelfilsdatabas förenklar säkerhetskopiering och migrering

De tekniker du lär dig gäller för alla Windows appar som behöver lagra strukturerade data lokalt, från lagring av enkla inställningar till komplexa datahanteringsscenarier.

Tips/Råd

Du kan använda AI-hjälp för att undvika SQL-inmatningsattacker i SQLite.

Fördelar med SQLite för lokal lagring

✔️ SQLite är lätt 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-biblioteket 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 använda samma kod i WinUI-appen och den fungerar med lämpliga ändringar i connection string.

För att prova det, se Komma igång med EF Core.

SQLite-bibliotek

Microsoft.Data.Sqlite-biblioteket 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 lösningen så att den använder Microsoft.Data.SQLite-biblioteket

Vi börjar med ett grundläggande WinUI-projekt och installerar sedan SQLite NuGet-paketet. Se Skapa en WinUI-app för instruktioner om hur du skapar ditt första WinUI-projekt.

Alla versioner av Windows som stöds stöder SQLite, så att din app inte behöver paketera SQLite-bibliotek. I stället kan appen 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. Den 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 projektet med namnet DataAccess. Om du planerar att dela dataåtkomstlogik med annan klientkod kan du använda ett .NET klassbiblioteksprojekt för att innehålla din dataåtkomstkod, men vi använder inte någon i vårt exempel.

  1. Högerklicka på lösningen och klicka sedan på Hantera NuGet-paket för lösning.

    En skärmbild av Visual Studio Solution Explorer med projektet högerklickat och alternativet Hantera NuGet-paket markerat.

    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 viss version av SQLite kan du inkludera SQLite-biblioteket i paketet. Vi kommer att använda den version av SQLite som ingår i Windows.

  2. Välj fliken Bläddra , sök efter Microsoft.Data.SQLite-paketet och installera sedan den senaste stabila versionen.

    SQLite NuGet-paket

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

DataAccess Öppna klassen i projektet och gör klassen statisk.

Anmärkning

Exemplet placerar din dataåtkomstkod i en statisk klass, men det här är 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 (var 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)";

        var createTable = new SqliteCommand(tableCommand, db);

        createTable.ExecuteReader();
    }
}

Anmärkning

Koden ovan som använder ApplicationData medlemmar fungerar bara för paketerade appar som körs i en appcontainer. Alla andra Windows appar bör ha åtkomst till ApplicationData-medlemmar via klassen ApplicationDataManager.

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. I ett produktionsprogram bör anslutningsinformation som databasfilens namn lagras i appkonfigurationen i stället för hårdkodad (se Tilldela Azure App Configuration med hjälp av Visual Studio Anslutna tjänster).

Anropa metoden från -klassen i konstruktorn för filen InitializeDatabase i ditt projekt. Detta säkerställer att databasen skapas eller öppnas varje gång appen startas.

public App()
{
    this.InitializeComponent();

    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 (var db = new SqliteConnection($"Filename={dbpath}"))
    {
        db.Open();

        var 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 alla rader med data från en tabell i vår SQLite-databas.

public static List<string> GetData()
{
    var entries = new List<string>();
    string dbpath = Path.Combine(ApplicationData.Current.LocalFolder.Path,
                                 "sqliteSample.db");
    using (var db = new SqliteConnection($"Filename={dbpath}"))
    {
        db.Open();
        var 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 så viktig i det här exemplet eftersom vi väljer alla poster inom en enda 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 filen MainWindow.xaml i projektet.

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
    <StackPanel>
        <TextBox x:Name="Input_Box"/>
        <Button Click="AddData">Add</Button>
        <ListView x: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 MainWindow.xaml.cs . Det här är den metod som vi har associerat med Click händelsen 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 MainWindow konstruktorn för att anropa GetData().

public MainWindow()
{
    this.InitializeComponent();

    Output.ItemsSource = DataAccess.GetData();
}

Klart! Utforska Microsoft.Data.Sqlite för att se vad andra saker du kan göra med din SQLite-databas. Kolla in länkarna nedan om du vill veta mer om andra sätt att använda data i dina Windows appar.

Undvik SQL-inmatningsattacker

Koden i det här exemplet använder parametriserade frågor för att förhindra SQL-inmatningsattacker. Sammanfoga aldrig användarindata till en SQL-frågesträng. Använd alltid parametrar. Du kan be Copilot om fler tips för att undvika SQL-inmatningsattacker.

Följande text visar ett exempel på en uppmaning om Copilot:

Can you provide some best practices to avoid SQL injection attacks when writing SQLite queries in C# code?

Copilot drivs av AI, så överraskningar och misstag är möjliga. Mer information finns i vanliga frågor och svar om Copilot.

Relaterat innehåll

Ansluta din app direkt till en SQL Server databas

Se till Använd en SQL Server-databas i en Windows-applikation.

Dela kod mellan olika appar på olika plattformar

Se Dela kod mellan skrivbordet och UWP.

Lägg till master-detaljsidor med Azure SQL bakändssystem

Se det här exemplet Customer Orders Database.

  • Last updated on