Speichern von Daten in einer lokalen SQLite.NET-Datenbank

Artikel
07/13/2023

Download Sample Das Beispiel herunterladen

In diesem Schnellstart lernen Sie, wie Sie:

Daten lokal in einer SQLite.NET-Datenbank speichern.

In dieser Schnellstartanleitung erfahren Sie, wie Sie Daten aus einer Xamarin.Forms-Shellanwendung in einer lokalen SQLite.NET-Datenbank speichern. Die fertige Anwendung wird unten gezeigt:

Voraussetzungen

Sie sollten den vorherigen Schnellstart erfolgreich abgeschlossen haben, bevor Sie mit diesem Schnellstart beginnen. Alternativ können Sie auch das letzte Schnellstartbeispiel herunterladen und als Startpunkt für diesen Schnellstart verwenden.

Aktualisieren der App mit Visual Studio

Starten Sie Visual Studio, und öffnen Sie die Projektmappe „Notizen“.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die Projektmappe Notes, und wählen Sie NuGet-Pakete für Projektmappe verwalten… aus:
Wählen Sie im NuGet-Paket-Manager die Registerkarte Durchsuchen aus, und suchen Sie nach dem NuGet-Paket sqlite-net-pcl.
Warnung

Es gibt eine Reihe von NuGet-Paketen mit ähnlichen Namen. Das richtige Paket verfügt über die folgenden Attribute:
- Ersteller: SQLite-net
- NuGet-Link:sqlite-net-pcl
Trotz des Paketnamens kann dieses NuGet-Paket in .NET Standard-Projekten verwendet werden.
Wählen Sie im NuGet-Paket-Manager das richtige sqlite-net-pcl-Paket aus, aktivieren Sie das Kontrollkästchen Projekt, und klicken Sie auf die Schaltfläche Installieren, um es dem Projekt hinzuzufügen:

Mit diesem Paket werden Datenbankvorgänge in die Anwendung einbezogen. Es wird jedem Projekt in der Projektmappe hinzugefügt.

Wichtig

SQLite.NET ist eine Drittanbieterbibliothek, die vom praeclarum/sqlite-net-Repository unterstützt wird.

Schließen Sie den NuGet-Paket-Manager.
Öffnen Sie im Projektmappen-Explorer im Projekt Notizen die Datei Note.cs im Ordner Modelle, und ersetzen Sie den vorhandenen Code durch den folgenden Code:
```
using System;
using SQLite;

namespace Notes.Models
{
    public class Note
    {
        [PrimaryKey, AutoIncrement]
        public int ID { get; set; }
        public string Text { get; set; }
        public DateTime Date { get; set; }
    }
}
```
Diese Klasse definiert ein Note-Modell, das Daten über jede Notiz in der Anwendung speichert. Die ID-Eigenschaft wird mit den Attributen PrimaryKey und AutoIncrement markiert, um sicherzustellen, dass jede Note-Instanz in der SQLite.NET-Datenbank über eine eindeutige ID verfügt, die von SQLite.NET vergeben wird.

Speichern Sie die Änderungen an Note.cs, indem Sie STRG+S drücken.

Warnung

Die Anwendung wird derzeit aufgrund von Fehlern, die in späteren Schritten korrigiert werden, nicht erstellt.
Fügen Sie im Projektmappen-Explorer einen neuen Ordner namens Daten zum Projekt Notizen hinzu.
Fügen Sie im Projektmappen-Explorer im Projekt Notizen dem Ordner Daten eine neue Klasse mit dem Namen NoteDatabase hinzu.

Ersetzen Sie in NoteDatabase.cs den vorhandenen Code durch den folgenden Code:

using System.Collections.Generic;
using System.Threading.Tasks;
using SQLite;
using Notes.Models;

namespace Notes.Data
{
    public class NoteDatabase
    {
        readonly SQLiteAsyncConnection database;

        public NoteDatabase(string dbPath)
        {
            database = new SQLiteAsyncConnection(dbPath);
            database.CreateTableAsync<Note>().Wait();
        }

        public Task<List<Note>> GetNotesAsync()
        {
            //Get all notes.
            return database.Table<Note>().ToListAsync();
        }

        public Task<Note> GetNoteAsync(int id)
        {
            // Get a specific note.
            return database.Table<Note>()
                            .Where(i => i.ID == id)
                            .FirstOrDefaultAsync();
        }

        public Task<int> SaveNoteAsync(Note note)
        {
            if (note.ID != 0)
            {
                // Update an existing note.
                return database.UpdateAsync(note);
            }
            else
            {
                // Save a new note.
                return database.InsertAsync(note);
            }
        }

        public Task<int> DeleteNoteAsync(Note note)
        {
            // Delete a note.
            return database.DeleteAsync(note);
        }
    }
}

Diese Klasse enthält Code, mit dem die Datenbank erstellt wird und Daten aus ihr gelesen bzw. in sie geschrieben und aus ihr gelöscht werden. Im Code werden asynchrone SQLite.NET-APIs verwendet, mit denen Datenbankvorgänge in Hintergrundthreads verschoben werden. Außerdem akzeptiert der NoteDatabase-Konstruktor den Pfad der Datenbankdatei als Argument. Dieser Pfad wird im nächsten Schritt von der App-Klasse bereitgestellt.

Speichern Sie die Änderungen an NoteDatabase.cs, indem Sie STRG+S drücken.

Warnung

Die Anwendung wird derzeit aufgrund von Fehlern, die in späteren Schritten korrigiert werden, nicht erstellt.

Erweitern Sie im Projektmappen-Explorer im Projekt Notes den Eintrag App.xaml, und doppelklicken Sie auf die Datei App.xaml.cs, um sie zu öffnen. Ersetzen Sie dann den vorhandenen Code durch folgenden Code:

using System;
using System.IO;
using Notes.Data;
using Xamarin.Forms;

namespace Notes
{
    public partial class App : Application
    {
        static NoteDatabase database;

        // Create the database connection as a singleton.
        public static NoteDatabase Database
        {
            get
            {
                if (database == null)
                {
                    database = new NoteDatabase(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Notes.db3"));
                }
                return database;
            }
        }

        public App()
        {
            InitializeComponent();
            MainPage = new AppShell();
        }

        protected override void OnStart()
        {
        }

        protected override void OnSleep()
        {
        }

        protected override void OnResume()
        {
        }
    }
}

Dieser Code definiert eine Database-Eigenschaft, die eine neue NoteDatabase-Instanz als Singleton erzeugt, wobei der Dateiname der Datenbank als Argument an den NoteDatabase-Konstruktor übergeben wird. Durch das Bereitstellen der Datenbank als Singleton kann eine einzelne Datenbankverbindung erstellt werden, die während der Ausführung der App offen bleibt, sodass der Aufwand für das Öffnen und Schließen der Datenbank beim Ausführen des Datenbankvorgangs vermieden wird.

Speichern Sie die Änderungen an App.xaml.cs, indem Sie STRG+S drücken.

Warnung

Die Anwendung wird derzeit aufgrund von Fehlern, die in späteren Schritten korrigiert werden, nicht erstellt.

Erweitern Sie im Projektmappen-Explorer im Projekt Notes den Eintrag NotesPage.xaml im Ordner Ansichten, und öffnen Sie die Datei NotesPage.xaml.cs. Ersetzen Sie dann die OnAppearing- und OnSelectionChanged-Methoden durch folgenden Code:
```
protected override async void OnAppearing()
{
    base.OnAppearing();

    // Retrieve all the notes from the database, and set them as the
    // data source for the CollectionView.
    collectionView.ItemsSource = await App.Database.GetNotesAsync();
}

async void OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
    if (e.CurrentSelection != null)
    {
        // Navigate to the NoteEntryPage, passing the ID as a query parameter.
        Note note = (Note)e.CurrentSelection.FirstOrDefault();
        await Shell.Current.GoToAsync($"{nameof(NoteEntryPage)}?{nameof(NoteEntryPage.ItemId)}={note.ID.ToString()}");
    }
}    
```
Die OnAppearing-Methode füllt die CollectionView mit allen Notizen auf, die in der Datenbank gespeichert sind. Die OnSelectionChanged-Methode navigiert zur NoteEntryPage und übergibt dabei die ID-Eigenschaft des ausgewählten Note-Objekts als Abfrageparameter.

Speichern Sie die Änderungen an NotesPage.xaml.cs, indem Sie STRG+S drücken.

Warnung

Die Anwendung wird derzeit aufgrund von Fehlern, die in späteren Schritten korrigiert werden, nicht erstellt.

Erweitern Sie im Projektmappen-Explorer den Eintrag NoteEntryPage.xaml im Ordner Ansichten, und öffnen Sie die Datei NoteEntryPage.xaml.cs. Ersetzen Sie dann die Methoden LoadNote, OnSaveButtonClicked und OnDeleteButtonClicked durch folgenden Code:

async void LoadNote(string itemId)
{
    try
    {
        int id = Convert.ToInt32(itemId);
        // Retrieve the note and set it as the BindingContext of the page.
        Note note = await App.Database.GetNoteAsync(id);
        BindingContext = note;
    }
    catch (Exception)
    {
        Console.WriteLine("Failed to load note.");
    }
}

async void OnSaveButtonClicked(object sender, EventArgs e)
{
    var note = (Note)BindingContext;
    note.Date = DateTime.UtcNow;
    if (!string.IsNullOrWhiteSpace(note.Text))
    {
        await App.Database.SaveNoteAsync(note);
    }

    // Navigate backwards
    await Shell.Current.GoToAsync("..");
}

async void OnDeleteButtonClicked(object sender, EventArgs e)
{
    var note = (Note)BindingContext;
    await App.Database.DeleteNoteAsync(note);

    // Navigate backwards
    await Shell.Current.GoToAsync("..");
}

Die NoteEntryPage verwendet die LoadNote-Methode, um die Notiz aus der Datenbank abzurufen, deren ID als Abfrageparameter an die Seite übergeben wurde, und speichert sie als Note-Objekt im BindingContext der Seite. Wenn der OnSaveButtonClicked-Ereignishandler ausgeführt wird, wird die Note-Instanz in der Datenbank gespeichert, und die Anwendung navigiert zur vorherigen Seite zurück. Wenn der OnDeleteButtonClicked-Ereignishandler ausgeführt wird, wird die Note-Instanz aus der Datenbank gelöscht, und die Anwendung navigiert zur vorherigen Seite zurück.

Speichern Sie die Änderungen an NoteEntryPage.xaml.cs, indem Sie STRG+S drücken.

Erstellen Sie das Projekt auf jeder Plattform, und führen Sie dieses aus. Weitere Informationen finden Sie unter Erstellen des Schnellstarts.

Klicken Sie auf der NotesPage auf die Schaltfläche Hinzufügen, um zur NoteEntryPage zu navigieren und eine Notiz einzugeben. Nach dem Speichern der Notiz navigiert die Anwendung zurück zur Eigenschaft NotesPage.

Geben Sie verschiedene Notizen unterschiedlicher Länge ein, um das Verhalten der Anwendung zu beobachten. Schließen Sie die Anwendung, und starten Sie sie neu, um sicherzustellen, dass die von Ihnen eingegebenen Notizen in der Datenbank gespeichert wurden.

Aktualisieren der App mit Visual Studio für Mac

Starten Sie Visual Studio für Mac, und öffnen Sie die Lösungsmappe „Notes“.
Klicken Sie im Lösungspad mit der rechten Maustaste auf die Projektmappe Notes, und wählen Sie NuGet-Pakete verwalten... aus:
Wählen Sie im Dialogfeld NuGet-Pakete verwalten die Registerkarte Durchsuchen aus, und suchen Sie nach dem NuGet-Paket sqlite-net-pcl.
Warnung

Es gibt eine Reihe von NuGet-Paketen mit ähnlichen Namen. Das richtige Paket verfügt über die folgenden Attribute:
- Ersteller: SQLite-net
- NuGet-Link:sqlite-net-pcl
Trotz des Paketnamens kann dieses NuGet-Paket in .NET Standard-Projekten verwendet werden.
Wählen Sie im Dialogfeld NuGet-Pakete verwalten das NuGet-Paket sqlite-net-pcl aus, und klicken Sie auf die Schaltfläche Paket hinzufügen, um es der Projektmappe hinzuzufügen:

Mit diesem Paket können Datenbankvorgänge in der Anwendung verwendet werden.
Stellen Sie im Dialogfeld Projekte auswählen sicher, dass jedes Kontrollkästchen aktiviert ist, und klicken Sie auf die Schaltfläche OK:

Dadurch wird das NuGet-Paket zu jedem Projekt in der Projektmappe hinzugefügt.
Öffnen Sie im Lösungspad im Projekt Notizen die Datei Note.cs im Ordner Modelle, und ersetzen Sie den vorhandenen Code durch den folgenden Code:
```
using System;
using SQLite;

namespace Notes.Models
{
    public class Note
    {
        [PrimaryKey, AutoIncrement]
        public int ID { get; set; }
        public string Text { get; set; }
        public DateTime Date { get; set; }
    }
}
```
Diese Klasse definiert ein Note-Modell, das Daten über jede Notiz in der Anwendung speichert. Die ID-Eigenschaft wird mit den Attributen PrimaryKey und AutoIncrement markiert, um sicherzustellen, dass jede Note-Instanz in der SQLite.NET-Datenbank über eine eindeutige ID verfügt, die von SQLite.NET vergeben wird.

Speichern Sie die Änderungen an Note.cs, indem Sie Datei > Sichern auswählen (oder ⌘ + S drücken).

Warnung

Die Anwendung wird derzeit aufgrund von Fehlern, die in späteren Schritten korrigiert werden, nicht erstellt.
Fügen Sie im Lösungspad einen neuen Ordner namens Daten zum Projekt Notizen hinzu.
Fügen Sie im Lösungspad im Projekt Notizen dem Ordner Daten eine neue Klasse mit dem Namen NoteDatabase hinzu.

Ersetzen Sie in NoteDatabase.cs den vorhandenen Code durch den folgenden Code:

using System.Collections.Generic;
using System.Threading.Tasks;
using SQLite;
using Notes.Models;

namespace Notes.Data
{
    public class NoteDatabase
    {
        readonly SQLiteAsyncConnection database;

        public NoteDatabase(string dbPath)
        {
            database = new SQLiteAsyncConnection(dbPath);
            database.CreateTableAsync<Note>().Wait();
        }

        public Task<List<Note>> GetNotesAsync()
        {
            //Get all notes.
            return database.Table<Note>().ToListAsync();
        }

        public Task<Note> GetNoteAsync(int id)
        {
            // Get a specific note.
            return database.Table<Note>()
                            .Where(i => i.ID == id)
                            .FirstOrDefaultAsync();
        }

        public Task<int> SaveNoteAsync(Note note)
        {
            if (note.ID != 0)
            {
                // Update an existing note.
                return database.UpdateAsync(note);
            }
            else
            {
                // Save a new note.
                return database.InsertAsync(note);
            }
        }

        public Task<int> DeleteNoteAsync(Note note)
        {
            // Delete a note.
            return database.DeleteAsync(note);
        }
    }
}

Speichern Sie die Änderungen an NoteDatabase.cs, indem Sie Datei > Sichern auswählen (oder ⌘ + S drücken).

Warnung

Die Anwendung wird derzeit aufgrund von Fehlern, die in späteren Schritten korrigiert werden, nicht erstellt.

Erweitern Sie im Lösungspad im Projekt Notes den Eintrag App.xaml, und doppelklicken Sie auf die Datei App.xaml.cs, um sie zu öffnen. Ersetzen Sie dann den vorhandenen Code durch folgenden Code:

using System;
using System.IO;
using Notes.Data;
using Xamarin.Forms;

namespace Notes
{
    public partial class App : Application
    {
        static NoteDatabase database;

        // Create the database connection as a singleton.
        public static NoteDatabase Database
        {
            get
            {
                if (database == null)
                {
                    database = new NoteDatabase(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Notes.db3"));
                }
                return database;
            }
        }

        public App()
        {
            InitializeComponent();
            MainPage = new AppShell();
        }

        protected override void OnStart()
        {
        }

        protected override void OnSleep()
        {
        }

        protected override void OnResume()
        {
        }
    }
}

Speichern Sie die Änderungen an App.xaml.cs, indem Sie Datei > Sichern auswählen (oder ⌘ + S drücken).

Warnung

Die Anwendung wird derzeit aufgrund von Fehlern, die in späteren Schritten korrigiert werden, nicht erstellt.

Erweitern Sie im Lösungspad im Projekt Notes den Eintrag NotesPage.xaml im Ordner Ansichten, und öffnen Sie die Datei NotesPage.xaml.cs. Ersetzen Sie dann die OnAppearing- und OnSelectionChanged-Methoden durch folgenden Code:
```
protected override async void OnAppearing()
{
    base.OnAppearing();

    // Retrieve all the notes from the database, and set them as the
    // data source for the CollectionView.
    collectionView.ItemsSource = await App.Database.GetNotesAsync();
}

async void OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
    if (e.CurrentSelection != null)
    {
        // Navigate to the NoteEntryPage, passing the ID as a query parameter.
        Note note = (Note)e.CurrentSelection.FirstOrDefault();
        await Shell.Current.GoToAsync($"{nameof(NoteEntryPage)}?{nameof(NoteEntryPage.ItemId)}={note.ID.ToString()}");
    }
}    
```
Die OnAppearing-Methode füllt die CollectionView mit allen Notizen auf, die in der Datenbank gespeichert sind. Die OnSelectionChanged-Methode navigiert zur NoteEntryPage und übergibt dabei die ID-Eigenschaft des ausgewählten Note-Objekts als Abfrageparameter.

Speichern Sie die Änderungen an NotesPage.xaml.cs, indem Sie Datei > Sichern auswählen (oder ⌘ + S drücken).

Warnung

Die Anwendung wird derzeit aufgrund von Fehlern, die in späteren Schritten korrigiert werden, nicht erstellt.
Erweitern Sie im Lösungspad den Eintrag NoteEntryPage.xaml im Ordner Ansichten, und öffnen Sie die Datei NoteEntryPage.xaml.cs. Ersetzen Sie dann die Methoden LoadNote, OnSaveButtonClicked und OnDeleteButtonClicked durch folgenden Code:
```
async void LoadNote(string itemId)
{
    try
    {
        int id = Convert.ToInt32(itemId);
        // Retrieve the note and set it as the BindingContext of the page.
        Note note = await App.Database.GetNoteAsync(id);
        BindingContext = note;
    }
    catch (Exception)
    {
        Console.WriteLine("Failed to load note.");
    }
}

async void OnSaveButtonClicked(object sender, EventArgs e)
{
    var note = (Note)BindingContext;
    note.Date = DateTime.UtcNow;
    if (!string.IsNullOrWhiteSpace(note.Text))
    {
        await App.Database.SaveNoteAsync(note);
    }

    // Navigate backwards
    await Shell.Current.GoToAsync("..");
}

async void OnDeleteButtonClicked(object sender, EventArgs e)
{
    var note = (Note)BindingContext;
    await App.Database.DeleteNoteAsync(note);

    // Navigate backwards
    await Shell.Current.GoToAsync("..");
}
```
Die NoteEntryPage verwendet die LoadNote-Methode, um die Notiz aus der Datenbank abzurufen, deren ID als Abfrageparameter an die Seite übergeben wurde, und speichert sie als Note-Objekt im BindingContext der Seite. Wenn der OnSaveButtonClicked-Ereignishandler ausgeführt wird, wird die Note-Instanz in der Datenbank gespeichert, und die Anwendung navigiert zur vorherigen Seite zurück. Wenn der OnDeleteButtonClicked-Ereignishandler ausgeführt wird, wird die Note-Instanz aus der Datenbank gelöscht, und die Anwendung navigiert zur vorherigen Seite zurück.

Speichern Sie die Änderungen an NoteEntryPage.xaml.cs, indem Sie Datei > Sichern auswählen (oder ⌘ + S drücken).
Erstellen Sie das Projekt auf jeder Plattform, und führen Sie dieses aus. Weitere Informationen finden Sie unter Erstellen des Schnellstarts.

Klicken Sie auf der NotesPage auf die Schaltfläche Hinzufügen, um zur NoteEntryPage zu navigieren und eine Notiz einzugeben. Nach dem Speichern der Notiz navigiert die Anwendung zurück zur Eigenschaft NotesPage.

Geben Sie verschiedene Notizen unterschiedlicher Länge ein, um das Verhalten der Anwendung zu beobachten. Schließen Sie die Anwendung, und starten Sie sie neu, um sicherzustellen, dass die von Ihnen eingegebenen Notizen in der Datenbank gespeichert wurden.

Nächste Schritte

In diesem Schnellstart haben Sie gelernt, wie Sie:

Daten lokal in einer SQLite.NET-Datenbank speichern.

Fahren Sie mit der nächsten Schnellstartanleitung fort, um die Anwendung mit XAML-Formatvorlagen zu gestalten.

Speichern von Daten in einer lokalen SQLite.NET-Datenbank

Voraussetzungen

Aktualisieren der App mit Visual Studio

Aktualisieren der App mit Visual Studio für Mac

Nächste Schritte

Verwandte Links

Zusätzliche Ressourcen