Übung: Lokales Speichern von Daten mit SQLite

  • 15 Minuten

In dieser Übung verwenden Sie SQLite zum lokalen Speichern von Informationen mit einer Anwendung. Im Beispielszenario haben Sie beschlossen, Daten für die Social Media-App zwischenzuspeichern, um die Reaktionsfähigkeit zu verbessern. In dieser Übung erstellen und verwenden Sie eine lokale SQLite-Datenbank zum Speichern von Informationen über Personen. Sie speichern die physische Datenbankdatei im lokalen Speicher.

In diesem Modul wird das .NET 9.0 SDK verwendet. Stellen Sie sicher, dass .NET 9.0 installiert ist, indem Sie in Ihrem bevorzugten Befehlsterminal den folgenden Befehl ausführen:

dotnet --list-sdks

Die daraufhin angezeigte Ausgabe sieht in etwa wie im folgenden Beispiel aus:

8.0.100 [C:\Program Files\dotnet\sdk]
9.0.100 [C:\Program Files\dotnet\sdk]

Stellen Sie sicher, dass eine Version aufgeführt wird, die mit 9 beginnt. Wenn nichts aufgeführt ist oder der Befehl nicht gefunden wurde, installieren Sie das neueste .NET 9.0 SDK.

Öffnen der Startprojektmappe

  1. Klonen Sie das Übungsrepository, oder laden Sie es herunter.

    Hinweis

    Es empfiehlt sich, den Übungsinhalt in einen kurzen Ordnerpfad wie z. B. C:\dev zu klonen. So vermeiden Sie, dass vom Build generierte Dateien die maximale Pfadlänge überschreiten.

  2. Verwenden Sie Visual Studio, um die Lösung People.sln zu öffnen, die Sie in mslearn-dotnetmaui-store-local-data>People oder im Ordner „starter“ in Visual Studio Code finden.

    Hinweis

    Versuchen Sie noch nicht, die Anwendung auszuführen. Der Code ist unvollständig und wird Ausnahmen auslösen, bis Sie die fehlenden Elemente später in dieser Übung hinzufügen.

Definieren einer SQLite-Entität

  1. Öffnen Sie die Datei Person.cs im Ordner Modelle.

  2. Fügen Sie der Person-Klasse eine int-Eigenschaft hinzu, die Id genannt wird.

  3. Eine string-Eigenschaft namens Name. Die Klasse sollte wie folgt aussehen:

    namespace People.Models;

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
}

  4. Speichern Sie die Datei Person.cs.

Hinzufügen der SQLite-Bibliothek

  1. Klicken Sie in Visual Studio im Projektmappen-Explorer mit der rechten Maustaste auf den Projektknoten Personen.

  2. Klicken Sie im daraufhin angezeigten Kontextmenü auf NuGet-Pakete verwalten.

  3. Suchen und wählen Sie sqlite-net-pcl und dann Installieren aus.

    Screenshot des NuGet-Paket-Managers mit ausgewählter Sequel-Net-Light-PCL-Bibliothek.

Wenn Sie Visual Studio Code verwenden, öffnen Sie das Terminal und diese Pakete mit den folgenden Befehlen:

dotnet add package sqlite-net-pcl

Hinzufügen von SQLite-Attributen

  1. Fügen Sie in der Datei Person.cs eine using-Direktive für den SQLite-Namespace für die Person Klasse hinzu. Mit dieser Direktive können Sie die SQLite-Attribute verwenden.

    using SQLite;

namespace People.Models;

public class Person
{
    ...
}

  2. Kommentieren Sie die Person-Klasse mit dem [Table]-Attribut, und legen Sie den Tabellennamen auf people fest.

  3. Geben Sie die Id-Eigenschaft als Primärschlüssel an. Kommentieren Sie sie mit den [PrimaryKey]- und [AutoIncrement]-Attributen.

  4. Fügen Sie der Eigenschaft Name Anmerkungen hinzu. Geben Sie für MaxLength 250 an. Legen Sie fest, dass jeder Wert in der Spalte Unique sein soll.

    Die vollständige Klasse sollte so aussehen:

    using SQLite;

namespace People.Models;

[Table("people")]
public class Person
{
    [PrimaryKey, AutoIncrement]
    public int Id { get; set; }

    [MaxLength(250), Unique]
    public string Name { get; set; }
}

  5. Speichern Sie die Datei Person.cs.

Herstellen der Verbindung mit der Datenbank

  1. Öffnen Sie die Datei PersonRepository.cs.

  2. Untersuchen Sie die Klasse PersonRepository. Diese Klasse enthält unvollständigen Skelettcode mit TODO-Markern, an denen Sie die Funktionalität für den Zugriff auf die Datenbank hinzufügen werden.

  3. Fügen Sie der Datei für die Klasse PersonRepository.cs eine using-Anweisung für die Namespaces SQLite und People.Models hinzu.

  4. Fügen Sie der Klasse oberhalb der Init-Funktion ein privates SQLiteConnection-Feld hinzu, das conn genannt wird.

  5. Überprüfen Sie in der Funktion Init, ob conn ungleich null ist. Wenn das zutrifft, kehren Sie sofort zurück.

    if (conn != null)
    return;

    Auf diese Weise wird der Initialisierungscode für die SQLite-Datenbank nur einmal ausgeführt.

  6. Initialisieren Sie das Feld conn, um mithilfe der Variablen _dbPath eine Verbindung mit der Datenbank herzustellen.

  7. Verwenden Sie die conn.CreateTable-Methode, um eine Tabelle zum Speichern von Person-Daten zu erstellen. Die vollständige Funktion Init sollte so aussehen:

    using SQLite;
using People.Models;
...

private SQLiteConnection conn;
...
private void Init()
{
   if (conn != null)
      return;

   conn = new SQLiteConnection(_dbPath);
   conn.CreateTable<Person>();
}

Einfügen einer Zeile in die Datenbank

  1. Suchen Sie in der PersonRepository-Klasse die AddNewPerson-Methode.

  2. Ersetzen Sie den Kommentar TODO in dieser Methode durch Code, um ein neues Person-Objekt einzufügen. Der Code ruft zuerst Init auf, um zu überprüfen, ob die Datenbank initialisiert ist, und verwendet dann die Insert-Methode des SQLiteConnection-Objekts. Legen Sie die result-Variable auf den Wert fest, den die Insert-Methode zurückgibt, wie im folgenden Code dargestellt wird:

    public void AddNewPerson(string name)
{
    int result = 0;
    try
    {
        // enter this line
        Init();

        // basic validation to ensure a name was entered
        if (string.IsNullOrEmpty(name))
            throw new Exception("Valid name required");

        // enter this line
        result = conn.Insert(new Person { Name = name });
        ...
    }
    ...
}

Abrufen von Zeilen aus der Datenbank

  1. Suchen Sie in der PersonRepository-Klasse die Methode GetAllPeople.

  2. Rufen Sie Init auf, um zu überprüfen, ob die Datenbank initialisiert wurde.

  3. Verwenden Sie die generische Table\<T>-Methode zum Abrufen aller Zeilen in der Tabelle. Geben Sie Person als Typparameter an.

  4. Verwenden Sie die Erweiterungsmethode ToList(), um das Ergebnis in eine List\<Person>-Sammlung umzuwandeln und diese Sammlung zurückzugeben.

  5. Fügen Sie die Fehlerbehandlung hinzu, indem Sie Ihren Code in einem try-catch-Block umschließen. Wenn ein Fehler auftritt, legen Sie die StatusMessage-Eigenschaft auf die Message-Eigenschaft der Ausnahme fest, und geben Sie eine leere Sammlung zurück. Die vollständige Methode sollte so aussehen:

    public List<Person> GetAllPeople()
{
   try
   {
      Init();
      return conn.Table<Person>().ToList();
   }
   catch (Exception ex)
   {
      StatusMessage = string.Format("Failed to retrieve data. {0}", ex.Message);
   }

   return new List<Person>();
}

  6. Speichern Sie die Datei PersonRepository.cs.

Integrieren des Repositorys in die Benutzeroberfläche

  1. Öffnen Sie die Datei MauiProgram.cs.

  2. Fügen Sie in der Funktion CreateMauiApp hinter den Anweisungen, die der App die Seite MainPage als Singleton-Dienst hinzufügen, Code zur Ausführung der folgenden Aufgaben hinzu:

    • Erstellen Sie eine Zeichenfolgenvariable namens dbPath. Initialisieren Sie diese Zeichenfolge mit dem Ausdruck FileAccessHelper.GetLocalFilePath("people.db3"). Die von der App verwendete Datenbankdatei heißt people.db3, und die App speichert diese Datei im lokalen Speicher auf dem Gerät.

    • Verwenden Sie die Abhängigkeitsinjektion, um der App die Klasse PersonRepository als Singleton-Dienst hinzuzufügen. Die Klasse PersonRepository macht einen Konstruktor verfügbar, der den Pfad zur Datenbankdatei als Zeichenfolgenparameter übernimmt.

    Der fertige Code für die CreateMauiApp-Funktion sollte wie folgt aussehen:

    public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    builder
        .UseMauiApp<App>()
        .ConfigureFonts(fonts =>
        {
            fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
            fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
        });

    // Add this code
    string dbPath = FileAccessHelper.GetLocalFilePath("people.db3");
    builder.Services.AddSingleton<PersonRepository>(s => ActivatorUtilities.CreateInstance<PersonRepository>(s, dbPath));

    return builder.Build();
}

  3. Öffnen Sie die Datei MauiProgram.cs.

  4. Erweitern Sie App.xaml im Projektmappen-Explorer, und öffnen Sie dann die Datei App.xaml.cs.

  5. Fügen Sie eine public und static Eigenschaft namens PersonRepo hinzu. Diese Eigenschaft enthält ein PersonRepository-Objekt in der App-Klasse.

  6. Initialisieren Sie die Eigenschaft PersonRepo im Konstruktor, indem Sie ihm einen PersonRepository-Parameter hinzufügen und die Eigenschaft ‚PersonRepo‘ auf den Wert in diesem Parameter festlegen. Die vollständige App-Klasse sollte so aussehen:

    public partial class App : Application
{
    public static PersonRepository PersonRepo { get; private set; }

    public App(PersonRepository repo)
    {
        InitializeComponent();
        PersonRepo = repo;
    }
}

Hinweis

Der Abhängigkeitseinfügungsprozess füllt den repo-Parameter automatisch dem Konstruktor auf.

Testen der App

  1. Erstellen Sie die Projektmappe, indem Sie STRG+UMSCHALT+B drücken.

  2. Beginnen Sie nach Abschluss des Builds mit dem Debuggen, indem Sie auf F5 drücken. Wenn die Benutzeroberfläche angezeigt wird, geben Sie Ihren Namen ein, und klicken Sie auf Person hinzufügen.

    Screenshot der App mit der Erfolgsmeldung, dass ein Datensatz hinzugefügt wurde

  3. Klicken Sie auf Alle Personen abrufen und überprüfen Sie, ob Ihr Name angezeigt wird.

    Screenshot der App mit einer Liste aller Datensätze in der Datenbank.

  4. Experimentieren Sie, indem Sie weitere Namen hinzufügen und die Liste von gespeicherten Personen abrufen.

  5. Kehren Sie zu Visual Studio oder Visual Studio Code zurück und beenden Sie das Debugging mit der Tastenkombination UMSCHALT+F5.

  6. Starten Sie die App neu, und wählen Sie Alle Personen abrufen aus. Überprüfen Sie, ob die zuvor gespeicherten Namen in der Datenbank weiterhin gespeichert sind. Schließen Sie die App, wenn Sie fertig sind.