Verwenden einer SQLite-Datenbank in einer UWP-App

Sie können SQLite verwenden, um Daten in einer einfachen Datenbank auf dem Gerät des Benutzers zu speichern und abzurufen. Dieser Leitfaden zeigt Ihnen wie.

Einige Vorteile der Verwendung von SQLite für die lokale Speicherung

✔️ SQLite ist einfach und eigenständig. Es ist eine Code-Bibliothek ohne weitere Abhängigkeiten. Es gibt nichts zu konfigurieren.

✔️ Es gibt keinen Datenbankserver. Client und der Server laufen im selben Prozess.

✔️ SQLite ist öffentlich zugänglich, so dass Sie es mit Ihrer App frei verwenden und verteilen können.

✔️ SQLite arbeitet plattform- und architekturübergreifend.

Mehr über SQLite erfahren Sie hier.

Auswählen einer Abstraktionsschicht

Wir empfehlen, dass Sie entweder Entity Framework Core oder die Open-Source-SQLite-Bibliothek von Microsoft verwenden.

Entity Framework Core

Entity Framework (EF) ist eine objektrelationale Zuordnung, die Ihnen über domänenspezifische Objekte die Verwendung relationaler Daten ermöglicht. Wenn Sie dieses Framework bereits für die Arbeit mit Daten in anderen .NET-Apps verwendet haben, können Sie diesen Code in eine UWP-App migrieren. Es funktioniert mit entsprechenden Änderungen an der Verbindungszeichenfolge.

Um es auszuprobieren, ziehen Sie Erste Schritte mit EF Core zurate.

SQLite-Bibliothek

Die Microsoft.Data.Sqlite-Bibliothek implementiert die Schnittstellen im System.Data.Common-Namespace. Microsoft pflegt diese Implementierungen aktiv und bietet einen intuitiven Wrapper für die native SQLite-API auf niedriger Ebene.

Der Rest dieses Leitfadens hilft Ihnen bei der Verwendung dieser Bibliothek.

Einrichten Ihrer Lösung für die Verwendung der Microsoft.Data.SQlite Bibliothek

Wir beginnen mit einem einfachen UWP-Projekt und installieren dann die entsprechenden Nuget-Pakete.

Alle unterstützten Versionen von Windows unterstützen SQLite, sodass Ihre App keine SQLite-Bibliotheken packen muss. Stattdessen kann Ihre App die Version von SQLite verwenden, die mit Windows installiert wird. Das hilft Ihnen in mehrfacher Hinsicht.

✔️ Reduziert die Größe Ihrer App, da Sie die SQLite-Binärdatei nicht herunterladen und dann als Teil Ihrer App verpacken müssen.

✔️ Verhindert, dass Sie eine neue Version Ihrer App an Benutzer weitergeben müssen, falls SQLite wichtige Fixes für Fehler und Sicherheitsschwachstellen in SQLite veröffentlicht. Die Windows-Version von SQLite wird von Microsoft in Abstimmung mit SQLite.org gepflegt.

✔️ Die Ladezeit der App kann kürzer sein, da die SDK-Version von SQLite wahrscheinlich bereits in den Speicher geladen wird.

Beginnen Sie mit dem Hinzufügen einer Klasse zu Ihrem UWP-Projekt mit dem Namen DataAccess. Sie können ein .NET Standard-Klassenbibliotheksprojekt verwenden, das Ihren Datenzugriffscode enthält, aber wir verwenden im vorliegenden Beispiel keine.

Klicken Sie mit der rechten Maustaste auf die Lösung, und klicken Sie dann auf NuGet-Pakete für Lösung verwalten.

An diesem Punkt haben Sie die Wahl. Sie können die Version von SQLite verwenden, die in Windows enthalten ist, oder wenn Sie einen Grund haben, eine bestimmte Version von SQLite zu verwenden, können Sie die SQLite-Bibliothek in Ihr Paket aufnehmen. Wir verwenden die Version von SQLite, die in Windows enthalten ist.

Wählen Sie die Registerkarte Durchsuchen aus, suchen Sie nach dem Paket Microsoft.Data.SQLite.Core, und installieren Sie die neueste stabile Version.

Hinzufügen und Abrufen von Daten in einer SQLite-Datenbank

Wir führen die folgenden Vorgänge aus:

1️⃣ Vorbereiten der Datenzugriffsklasse.

2️⃣ Initialisieren der SQLite-Datenbank.

3️⃣ Einfügen von Daten in die SQLite-Datenbank.

4️⃣ Abrufen von Daten aus der SQLite-Datenbank.

5️⃣ Hinzufügen einer einfachen Benutzeroberfläche.

Vorbereiten der Datenzugriffsklasse

Öffnen Sie die Klasse DataAccess in Ihrem Projekt, und machen Sie sich zu einer statischen Klasse.

public static class DataAccess
{

}

Fügen Sie die folgenden using-Anweisungen am Anfang dieser Datei hinzu.

using Microsoft.Data.Sqlite;
using System.Collections.Generic;

Initialisieren der SQLite-Datenbank

Fügen Sie der DataAccess-Klasse eine Methode hinzu, die die SQLite-Datenbank initialisiert.

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();
    }
}

Dieser Code erstellt die SQLite-Datenbank und speichert sie im lokalen Datenspeicher der Anwendung.

In diesem Beispiel benennen wir die Datenbank als sqlliteSample.db. Sie können aber jeden beliebigen Namen verwenden, solange Sie diesen Namen in allen instanziierten SqliteConnection-Objekten verwenden.

Rufen Sie im Konstruktor der Datei App.xaml.cs Ihres UWP-Projekts die InitializeDatabase-Methode der DataAccess-Klasse auf.

public App()
{
    this.InitializeComponent();
    this.Suspending += OnSuspending;

    DataAccess.InitializeDatabase();
}

Einfügen von Daten in die SQLite-Datenbank

Fügen Sie der DataAccess-Klasse eine Methode hinzu, die Daten in die SQLite-Datenbank einfügt. Dieser Code verwendet Parameter in der Abfrage, um Angriffe durch Einschleusung von SQL-Befehlen zu verhindern.

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();
    }

}

Abrufen von Daten aus der SQLite-Datenbank

Fügen Sie eine Methode hinzu, die Datenzeilen aus einer SQLite-Datenbank abruft.

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;
}

Die Read-Methode durchläuft die Zeilen der zurückgegebenen Daten. Sie gibt true zurück, wenn noch Zeilen übrig sind, andernfalls false.

Die GetString-Methode gibt den Wert der angegebenen Spalte als Zeichenfolge zurück. Sie akzeptiert einen Ganzzahlwert, der die nullbasierte Spalten-Ordinalzahl der gewünschten Daten darstellt. Sie können Methoden wie GetDataTime und GetBoolean verwenden. Wählen Sie eine Methode für den Datentyp der Spalte aus.

Der Ordinalparameter ist in diesem Beispiel nicht so wichtig, da wir alle Einträge in einer einzigen Spalte auswählen. Wenn jedoch mehrere Spalten Teil Ihrer Abfrage sind, verwenden Sie den Ordinalwert, um die Spalte zu erhalten, aus der Sie Daten abrufen möchten.

Hinzufügen einer einfachen Benutzeroberfläche

Fügen Sie in der Datei MainPage.xaml des UWP-Projekts den folgenden XAML-Code hinzu.

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

Diese grundlegende Benutzeroberfläche bietet dem Benutzer eine TextBox, über die er eine Zeichenfolge eingeben kann, die wir der SQLite-Datenbank hinzufügen. Wir verbinden den Button in dieser Benutzeroberfläche mit einem Ereignishandler, der Daten aus der SQLite-Datenbank abruft und diese Daten dann in der ListView anzeigt.

Fügen Sie in der Datei MainPage.xaml.cs den folgenden Handler hinzu. Dies ist die Methode, die wir dem Click-Ereignis des Button in der UI zugeordnet haben.

private void AddData(object sender, RoutedEventArgs e)
{
    DataAccess.AddData(Input_Box.Text);

    Output.ItemsSource = DataAccess.GetData();
}

Wir wollen auch sicherstellen, dass alle vorhandenen Daten beim Start der Anwendung geladen werden. Fügen Sie dem MainPage-Konstruktor eine Codezeile zum Aufrufen von GetData() hinzu.

public MainPage()
{
    this.InitializeComponent();

    Output.ItemsSource = DataAccess.GetData();
}

Das war's. Erkunden Sie Microsoft.Data.Sqlite, um zu erfahren, welche weiteren Vorgänge Sie mit Ihrer SQLite-Datenbank ausführen können. Besuchen Sie die Links unten, um mehr über andere Möglichkeiten der Datenverwendung in Ihrer UWP-App zu erfahren.

Nächste Schritte

Direktes Verbinden Ihrer App mit einer SQL Server-Datenbank

Informationen hierzu finden Sie unter Verwenden einer SQL Server-Datenbank in einer UWP-App.

Nutzen des gleichen Codes für verschiedene Apps auf verschiedenen Plattformen

Weitere Informationen finden Sie unter Migrieren von einer Desktopanwendung zu UWP.

Hinzufügen von Master/Detail-Seiten mit Azure SQL-Back-Ends

Weitere Informationen finden Sie unter Customers Orders Database sample (Beispiel für eine Kundenauftragsdatenbank).