Ćwiczenie: przechowywanie danych lokalnie za pomocą narzędzia SQLite

  • 15 min

W tym ćwiczeniu użyjesz sqlite do przechowywania informacji lokalnie z aplikacją. W przykładowym scenariuszu podjęto decyzję o buforowania danych aplikacji mediów społecznościowych w celu zwiększenia czasu reakcji. To ćwiczenie tworzy lokalną bazę danych SQLite i używa jej do przechowywania informacji o osobach. Plik fizycznej bazy danych jest zapisywany w magazynie lokalnym.

W tym module jest używany zestaw .NET 9.0 SDK. Upewnij się, że masz zainstalowany program .NET 9.0, uruchamiając następujące polecenie w preferowanym terminalu poleceń:

dotnet --list-sdks

Zostanie wyświetlone dane wyjściowe podobne do następującego przykładu:

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

Upewnij się, że na liście znajduje się wersja rozpoczynająca się od 9 . Jeśli na liście nie ma żadnej listy lub polecenie nie zostanie znalezione, zainstaluj najnowszy zestaw SDK platformy .NET 9.0.

Otwieranie rozwiązania startowego

  1. Sklonuj lub pobierz repozytorium ćwiczenia.

    Uwaga

    Najlepiej sklonować zawartość ćwiczenia do krótkiej ścieżki folderu, takiej jak C:\dev, aby uniknąć plików wygenerowanych przez kompilację przekraczającą maksymalną długość ścieżki.

  2. Użyj programu Visual Studio, aby otworzyć rozwiązanie People.sln, które można znaleźć w folderze mslearn-dotnetmaui-store-local-data>People lub folder startowy w programie Visual Studio Code.

    Uwaga

    Nie próbuj jeszcze uruchomić aplikacji, kod jest niekompletny i zgłasza wyjątki do momentu dodania brakujących elementów w dalszej części tego ćwiczenia.

Definiowanie jednostki SQLite

  1. Otwórz plik Person.cs w folderze Models.

  2. int Dodaj właściwość o nazwie Id do Person klasy.

  3. string Dodaj właściwość o nazwie Name. Klasa powinna wyglądać następująco:

    namespace People.Models;

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

  4. Zapisz plik Person.cs.

Dodawanie biblioteki SQLite

  1. Kliknij prawym przyciskiem myszy węzeł Projekt Osoby z Eksplorator rozwiązań w programie Visual Studio.

  2. W wyświetlonym menu kontekstowym wybierz pozycję Zarządzaj pakietami NuGet.

  3. Wyszukaj i wybierz pozycję sqlite-net-pcl, a następnie wybierz pozycję Zainstaluj.

    Zrzut ekranu przedstawiający menedżera pakietów NuGet z wybraną biblioteką sqlite-net-pcl.

W przypadku korzystania z programu Visual Studio Code otwórz terminal i te pakiety przy użyciu następujących poleceń:

dotnet add package sqlite-net-pcl

Dodawanie atrybutów SQLite

  1. W pliku Person.cs dodaj dyrektywę using dla SQLite przestrzeni nazw do pliku klasy Person . Ta dyrektywa umożliwia używanie atrybutów SQLite.

    using SQLite;

namespace People.Models;

public class Person
{
    ...
}

  2. Dodaj adnotację do Person klasy za pomocą atrybutu [Table] i określ nazwę tabeli jako people.

  3. Id Określ właściwość jako klucz podstawowy. Dodaj adnotację do atrybutów [PrimaryKey] i [AutoIncrement] .

  4. Dodaj adnotacje do Name właściwości . Określ jego MaxLength wartość 250. Określ, że każda wartość w kolumnie powinna mieć wartość Unique.

    Ukończona klasa powinna wyglądać następująco:

    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. Zapisz plik Person.cs.

Łączenie z bazą danych

  1. Otwórz plik PersonRepository.cs.

  2. Sprawdź klasę PersonRepository . Ta klasa zawiera niekompletny kod szkieletowy ze TODO znacznikami, w których dodajesz funkcjonalność w celu uzyskania dostępu do bazy danych.

  3. Dodaj dyrektywę using dla SQLite przestrzeni nazw i People.Models do pliku dla PersonRepository.cs klasy .

  4. Dodaj pole prywatne SQLiteConnection o nazwie conn do klasy powyżej Init funkcji.

  5. Init W funkcji sprawdź, czy conn nie jest równe null. Jeśli tak, wróć natychmiast.

    if (conn != null)
    return;

    W ten sposób kod inicjowania bazy danych SQLite jest uruchamiany tylko raz.

  6. Zainicjuj conn pole, aby nawiązać połączenie z bazą danych przy użyciu zmiennej _dbPath .

  7. conn.CreateTable Użyj metody , aby utworzyć tabelę do przechowywania Person danych. Ukończona Init funkcja powinna wyglądać następująco:

    using SQLite;
using People.Models;
...

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

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

Wstaw wiersz do bazy danych

  1. W PersonRepository klasie znajdź metodę AddNewPerson .

  2. Aby wstawić nowy Person obiekt, zastąp TODO komentarz w tej metodzie kodem. Kod najpierw wywołuje Init metodę , aby sprawdzić, czy baza danych jest zainicjowana, a następnie używa SQLiteConnection metody obiektu Insert . Ustaw zmienną result na wartość Insert zwracaną przez metodę, jak pokazano w poniższym kodzie:

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

Pobieranie wierszy z bazy danych

  1. PersonRepository W klasie znajdź metodę GetAllPeople .

  2. Wywołaj metodę Init , aby sprawdzić, czy baza danych została zainicjowana.

  3. Użyj metody ogólnej Table\<T> , aby pobrać wszystkie wiersze w tabeli. Określ Person jako parametr typu.

  4. ToList() Użyj metody rozszerzenia, aby przekształcić wynik w List\<Person> kolekcję i zwrócić tę kolekcję.

  5. Dodaj obsługę błędów, opakowując kod w try-catch bloku. Jeśli wystąpi błąd, ustaw StatusMessage właściwość na właściwość wyjątku Message i zwróć pustą kolekcję. Ukończona metoda powinna wyglądać następująco:

    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. Zapisz plik PersonRepository.cs.

Integrowanie repozytorium z interfejsem użytkownika

  1. Otwórz plik MauiProgram.cs.

  2. CreateMauiApp W funkcji po instrukcjach, które dodają MainPage stronę jako pojedynczą usługę do aplikacji, dodaj kod, aby wykonać następujące zadania:

    • Utwórz zmienną ciągu o nazwie dbPath. Zainicjuj ten ciąg za pomocą wyrażenia FileAccessHelper.GetLocalFilePath("people.db3"). Plik bazy danych używany przez aplikację nosi nazwę people.db3, a aplikacja zapisuje ten plik w magazynie lokalnym na urządzeniu.

    • Użyj iniekcji zależności, aby dodać klasę PersonRepository jako pojedynczą usługę do aplikacji. Klasa PersonRepository uwidacznia konstruktor, który pobiera ścieżkę do pliku bazy danych jako parametr ciągu.

    Ukończony kod funkcji CreateMauiApp powinien wyglądać następująco:

    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. Zapisz plik MauiProgram.cs.

  4. Rozwiń węzeł App.xaml w Eksplorator rozwiązań, a następnie otwórz plik App.xaml.cs.

  5. publicDodaj właściwość , static o nazwie PersonRepo. Ta właściwość przechowuje PersonRepository obiekt w App klasie .

  6. Zainicjuj PersonRepo właściwość w konstruktorze, dodając PersonRepository parametr do konstruktora i ustawiając właściwość PersonRepo na wartość w tym parametrze. Ukończona App klasa powinna wyglądać następująco:

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

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

Uwaga

Proces wstrzykiwania zależności automatycznie wypełnia repo parametr do konstruktora.

Testowanie aplikacji

  1. Skompiluj rozwiązanie przy użyciu CTRL+Shift+B.

  2. Po zakończeniu kompilacji rozpocznij debugowanie przy użyciu F5. Po wyświetleniu interfejsu użytkownika wprowadź swoje imię i nazwisko i wybierz pozycję Dodaj osobę.

    Zrzut ekranu aplikacji z komunikatem informującym o tym, że rekord został dodany.

  3. Wybierz pozycję Pobierz wszystkie osoby i sprawdź, czy twoje imię i nazwisko jest wyświetlane.

    Zrzut ekranu aplikacji z listą wszystkich rekordów w bazie danych.

  4. Poeksperymentuj, dodając więcej nazw i pobierając listę przechowywanych osób.

  5. Wróć do programu Visual Studio lub Visual Studio Code i zatrzymaj debugowanie przy użyciu Shift+F5.

  6. Uruchom ponownie aplikację i wybierz pozycję Pobierz wszystkie osoby. Sprawdź, czy nazwy przechowywane wcześniej są nadal przechowywane w bazie danych. Po zakończeniu zamknij aplikację.