Przechowywanie danych w lokalnej bazie danych biblioteki SQLite.NET

Artykuł
03/11/2024

Z tego przewodnika Szybki start dowiesz się, jak wykonywać następujące zadania:

Przechowywanie danych lokalnie w bazie danych SQLite.NET.

W przewodniku Szybki start przedstawiono sposób przechowywania danych w lokalnej bazie danych SQLite.NET z Xamarin.Forms poziomu aplikacji powłoki. Ostateczna aplikacja jest pokazana poniżej:

Wymagania wstępne

Przed podjęciem próby wykonania tego przewodnika Szybki start należy pomyślnie ukończyć poprzedni przewodnik Szybki start . Alternatywnie pobierz poprzedni przykład szybki start i użyj go jako punktu początkowego dla tego przewodnika Szybki start.

Aktualizowanie aplikacji za pomocą programu Visual Studio

Uruchom program Visual Studio i otwórz rozwiązanie Notatki.
W Eksplorator rozwiązań kliknij prawym przyciskiem myszy rozwiązanie Notatki i wybierz polecenie Zarządzaj pakietami NuGet dla rozwiązania...:
W Menedżer pakietów NuGet wybierz kartę Przeglądaj i wyszukaj pakiet NuGet sqlite-net-pcl.
Ostrzeżenie

Istnieje wiele pakietów NuGet o podobnych nazwach. Poprawny pakiet ma następujące atrybuty:
- Autorzy: SQLite-net
- Link pakietu NuGet:sqlite-net-pcl
Niezależnie od nazwy pakietu ten pakiet NuGet może być używany w projektach platformy .NET Standard.
W Menedżer pakietów NuGet wybierz prawidłowy pakiet sqlite-net-pcl, zaznacz pole wyboru Project (Projekt), a następnie kliknij przycisk Zainstaluj, aby dodać go do rozwiązania:

Ten pakiet będzie używany do dołączania operacji bazy danych do aplikacji i zostanie dodany do każdego projektu w rozwiązaniu.

Ważne

SQLite.NET to biblioteka innej firmy obsługiwana przez repozytorium praeclarum/sqlite-net.

Zamknij Menedżera pakietów NuGet.
W Eksplorator rozwiązań w projekcie Notatki otwórz Note.cs w folderze Models i zastąp istniejący kod następującym kodem:
```
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; }
    }
}
```
Ta klasa definiuje Note model, który będzie przechowywać dane dotyczące każdej notatki w aplikacji. Właściwość ID jest oznaczona atrybutami PrimaryKey i AutoIncrement w celu zapewnienia, że każde Note wystąpienie w bazie danych SQLite.NET będzie mieć unikatowy identyfikator dostarczony przez SQLite.NET.

Zapisz zmiany w Note.cs , naciskając klawisze CTRL+S.

Ostrzeżenie

Aplikacja nie będzie obecnie kompilować z powodu błędów, które zostaną naprawione w kolejnych krokach.
W Eksplorator rozwiązań dodaj nowy folder o nazwie Dane do projektu Notes.
W Eksplorator rozwiązań w projekcie Notatki dodaj nową klasę o nazwie NoteDatabase do folderu Data.

W NoteDatabase.cs zastąp istniejący kod następującym kodem:

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

Ta klasa zawiera kod umożliwiający utworzenie bazy danych, odczyt danych z niej, zapisanie w niej danych i usunięcie z niej danych. Kod używa asynchronicznych interfejsów API biblioteki SQLite.NET, które przenoszą operacje bazy danych do wątków w tle. Ponadto konstruktor NoteDatabase przyjmuje ścieżkę pliku bazy danych jako argument. Ta ścieżka zostanie udostępniona przez klasę App w następnym kroku.

Zapisz zmiany w NoteDatabase.cs , naciskając klawisze CTRL+S.

Ostrzeżenie

Aplikacja nie będzie obecnie kompilować z powodu błędów, które zostaną naprawione w kolejnych krokach.

W Eksplorator rozwiązań w projekcie Notes rozwiń węzeł App.xaml i kliknij dwukrotnie App.xaml.cs, aby go otworzyć. Następnie zastąp istniejący kod następującym kodem:

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

Ten kod definiuje Database właściwość, która tworzy nowe NoteDatabase wystąpienie jako pojedyncze wystąpienie, przekazując nazwę pliku bazy danych jako argument do konstruktora NoteDatabase . Korzyść z uwidaczniania bazy danych jako pojedynczej polega na tym, że jest tworzone połączenie pojedynczej bazy danych, które pozostaje otwarte podczas działania aplikacji, w związku z czym można uniknąć wydatków związanych z otwieraniem i zamykaniem pliku bazy danych za każdym razem, gdy jest wykonywana operacja bazy danych.

Zapisz zmiany w App.xaml.cs , naciskając klawisze CTRL+S.

Ostrzeżenie

Aplikacja nie będzie obecnie kompilować z powodu błędów, które zostaną naprawione w kolejnych krokach.

W Eksplorator rozwiązań w projekcie Notatki rozwiń węzeł NotesPage.xaml w folderze Views i otwórz NotesPage.xaml.cs. Następnie zastąp OnAppearing metody i OnSelectionChanged następującym kodem:

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

Metoda OnAppearing wypełnia obiekt wszystkimi CollectionView notatkami przechowywanymi w bazie danych. Metoda OnSelectionChanged przechodzi do NoteEntryPagemetody , przekazując ID właściwość wybranego Note obiektu jako parametr zapytania.

Zapisz zmiany w NotesPage.xaml.cs , naciskając klawisze CTRL+S.

Ostrzeżenie

Aplikacja nie będzie obecnie kompilować z powodu błędów, które zostaną naprawione w kolejnych krokach.

W Eksplorator rozwiązań rozwiń węzeł NoteEntryPage.xaml w folderze Views i otwórz NoteEntryPage.xaml.cs. Następnie zastąp LoadNotemetody , OnSaveButtonClickedi OnDeleteButtonClicked następującym kodem:

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

Metoda NoteEntryPage używa LoadNote metody , aby pobrać notatkę z bazy danych, której identyfikator został przekazany jako parametr zapytania do strony i zapisać go jako Note obiekt na BindingContext stronie. Po wykonaniu OnSaveButtonClicked programu obsługi zdarzeń wystąpienie jest zapisywane w bazie danych, Note a aplikacja przechodzi z powrotem do poprzedniej strony. Po wykonaniu OnDeleteButtonClicked programu obsługi zdarzeń wystąpienie zostanie usunięte z bazy danych, Note a aplikacja powróci do poprzedniej strony.

Zapisz zmiany w NoteEntryPage.xaml.cs , naciskając klawisze CTRL+S.

Skompiluj i uruchom projekt na każdej platformie. Aby uzyskać więcej informacji, zobacz Tworzenie przewodnika Szybki start.

Na stronie Notatki naciśnij przycisk Dodaj, aby przejść do strony NoteEntryPage i wprowadzić notatkę. Po zapisaniu notatki aplikacja wróci do notesu NotesPage.

Wprowadź kilka notatek o różnej długości, aby obserwować zachowanie aplikacji. Zamknij aplikację i uruchom ją ponownie, aby upewnić się, że wprowadzone notatki zostały zapisane w bazie danych.

Aktualizowanie aplikacji przy użyciu Visual Studio dla komputerów Mac

Uruchom Visual Studio dla komputerów Mac i otwórz rozwiązanie Notatki.
W okienku rozwiązania kliknij prawym przyciskiem myszy rozwiązanie Notatki i wybierz polecenie Zarządzaj pakietami NuGet...:
W oknie dialogowym Zarządzanie pakietami NuGet wybierz kartę Przeglądaj i wyszukaj pakiet NuGet sqlite-net-pcl.
Ostrzeżenie

Istnieje wiele pakietów NuGet o podobnych nazwach. Poprawny pakiet ma następujące atrybuty:
- Autorzy: SQLite-net
- Link pakietu NuGet:sqlite-net-pcl
Niezależnie od nazwy pakietu ten pakiet NuGet może być używany w projektach platformy .NET Standard.
W oknie dialogowym Zarządzanie pakietami NuGet wybierz pakiet sqlite-net-pcl, a następnie kliknij przycisk Dodaj pakiet, aby dodać go do rozwiązania:

Ten pakiet zostanie użyty w celu uwzględnienia operacji baz danych w aplikacji.
W oknie dialogowym Wybieranie projektów upewnij się, że każde pole wyboru jest zaznaczone i naciśnij przycisk OK:

Spowoduje to dodanie pakietu NuGet do każdego projektu w rozwiązaniu.
W okienku rozwiązania w projekcie Notatki otwórz Note.cs w folderze Models i zastąp istniejący kod następującym kodem:
```
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; }
    }
}
```
Ta klasa definiuje Note model, który będzie przechowywać dane dotyczące każdej notatki w aplikacji. Właściwość ID jest oznaczona atrybutami PrimaryKey i AutoIncrement w celu zapewnienia, że każde Note wystąpienie w bazie danych SQLite.NET będzie mieć unikatowy identyfikator dostarczony przez SQLite.NET.

Zapisz zmiany w Note.cs, wybierając pozycję Zapisz plik > (lub naciskając klawisz ⌘ + S).

Ostrzeżenie

Aplikacja nie będzie obecnie kompilować z powodu błędów, które zostaną naprawione w kolejnych krokach.
W okienku rozwiązania dodaj nowy folder o nazwie Data do projektu Notes.
W okienku rozwiązania w projekcie Notatki dodaj nową klasę o nazwie NoteDatabase do folderu Data.

W NoteDatabase.cs zastąp istniejący kod następującym kodem:

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

Zapisz zmiany w NoteDatabase.cs, wybierając pozycję Zapisz plik > (lub naciskając klawisz ⌘ + S).

Ostrzeżenie

Aplikacja nie będzie obecnie kompilować z powodu błędów, które zostaną naprawione w kolejnych krokach.

W okienku rozwiązania w projekcie Notatki rozwiń węzeł App.xaml i kliknij dwukrotnie App.xaml.cs, aby go otworzyć. Następnie zastąp istniejący kod następującym kodem:
```
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()
        {
        }
    }
}
```
Ten kod definiuje Database właściwość, która tworzy nowe NoteDatabase wystąpienie jako pojedyncze wystąpienie, przekazując nazwę pliku bazy danych jako argument do konstruktora NoteDatabase . Korzyść z uwidaczniania bazy danych jako pojedynczej polega na tym, że jest tworzone połączenie pojedynczej bazy danych, które pozostaje otwarte podczas działania aplikacji, w związku z czym można uniknąć wydatków związanych z otwieraniem i zamykaniem pliku bazy danych za każdym razem, gdy jest wykonywana operacja bazy danych.

Zapisz zmiany w App.xaml.cs, wybierając pozycję Zapisz plik > (lub naciskając klawisz ⌘ + S).

Ostrzeżenie

Aplikacja nie będzie obecnie kompilować z powodu błędów, które zostaną naprawione w kolejnych krokach.

W okienku rozwiązania w projekcie Notatki rozwiń węzeł NotesPage.xaml w folderze Views i otwórz NotesPage.xaml.cs. Następnie zastąp OnAppearing metody i OnSelectionChanged następującym kodem:

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

Zapisz zmiany w NotesPage.xaml.cs, wybierając pozycję Zapisz plik > (lub naciskając klawisz ⌘ + S).

Ostrzeżenie

Aplikacja nie będzie obecnie kompilować z powodu błędów, które zostaną naprawione w kolejnych krokach.

W okienku rozwiązania rozwiń węzeł NoteEntryPage.xaml w folderze Views i otwórz NoteEntryPage.xaml.cs. Następnie zastąp LoadNotemetody , OnSaveButtonClickedi OnDeleteButtonClicked następującym kodem:

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

Zapisz zmiany w NoteEntryPage.xaml.cs, wybierając pozycję Zapisz plik > (lub naciskając klawisz ⌘ + S).

Skompiluj i uruchom projekt na każdej platformie. Aby uzyskać więcej informacji, zobacz Tworzenie przewodnika Szybki start.

Na stronie Notatki naciśnij przycisk Dodaj, aby przejść do strony NoteEntryPage i wprowadzić notatkę. Po zapisaniu notatki aplikacja wróci do notesu NotesPage.

Wprowadź kilka notatek o różnej długości, aby obserwować zachowanie aplikacji. Zamknij aplikację i uruchom ją ponownie, aby upewnić się, że wprowadzone notatki zostały zapisane w bazie danych.

Następne kroki

W tym przewodniku Szybki start zawarto informacje na temat wykonywania następujących czynności:

Przechowywanie danych lokalnie w bazie danych SQLite.NET.

Przejdź do następnego przewodnika Szybki start, aby stylować aplikację przy użyciu stylów XAML.

Dalej

Przechowywanie danych w lokalnej bazie danych biblioteki SQLite.NET

Wymagania wstępne

Aktualizowanie aplikacji za pomocą programu Visual Studio

Aktualizowanie aplikacji przy użyciu Visual Studio dla komputerów Mac

Następne kroki

Pokrewne łącza

Dodatkowe zasoby