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

15 minut

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 10.0 SDK. Upewnij się, że masz zainstalowany program .NET 10.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:

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

Upewnij się, że na liście znajduje się wersja rozpoczynająca się od 10 . Jeśli nic nie jest wymienione lub nie można odnaleźć polecenia, zainstaluj najnowszy zestaw SDK platformy .NET 10.0.

Otwieranie rozwiązania startowego

Sklonuj lub pobierz repozytorium ćwiczeń.

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.
Użyj programu Visual Studio, aby otworzyć rozwiązanie People.sln , które znajduje się 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

Otwórz plik Person.cs w folderze Models .
int Dodaj właściwość o nazwie Id do Person klasy.

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

Zapisz plik Person.cs .

Dodawanie biblioteki SQLite

Kliknij prawym przyciskiem myszy na węźle projektu Osoby w Eksploratorze rozwiązań w programie Visual Studio.
W wyświetlonym menu kontekstowym wybierz pozycję Zarządzaj pakietami NuGet.
Wyszukaj i wybierz pozycję sqlite-net-pcl, a następnie wybierz pozycję Zainstaluj.

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

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
{
    ...
}
```
Dodaj adnotację do Person klasy za pomocą atrybutu [Table] i określ nazwę tabeli jako people.
Id Określ właściwość jako klucz podstawowy. Dodaj adnotację do atrybutów [PrimaryKey] i [AutoIncrement] .

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

Zapisz plik Person.cs .

Łączenie z bazą danych

Otwórz plik PersonRepository.cs .
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.
Dodaj dyrektywę using dla SQLite przestrzeni nazw i People.Models do pliku dla PersonRepository.cs klasy .
Dodaj pole prywatne SQLiteConnection o nazwie conn do klasy powyżej Init funkcji.
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.
Zainicjuj conn pole, aby nawiązać połączenie z bazą danych przy użyciu zmiennej _dbPath .

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

W PersonRepository klasie znajdź metodę AddNewPerson .

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

PersonRepository W klasie znajdź metodę GetAllPeople .
Wywołaj metodę Init , aby sprawdzić, czy baza danych została zainicjowana.
Użyj metody ogólnej Table\<T> , aby pobrać wszystkie wiersze w tabeli. Określ Person jako parametr typu.
ToList() Użyj metody rozszerzenia, aby przekształcić wynik w List\<Person> kolekcję i zwrócić tę kolekcję.

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

Zapisz plik PersonRepository.cs .

Integrowanie repozytorium z interfejsem użytkownika

Otwórz plik MauiProgram.cs .
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();
}
```
Zapisz plik MauiProgram.cs .
Rozwiń węzeł App.xaml w Eksploratorze Rozwiązań, a następnie otwórz plik App.xaml.cs.
publicDodaj właściwość , static o nazwie PersonRepo. Ta właściwość przechowuje PersonRepository obiekt w App klasie .
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

Skompiluj rozwiązanie przy użyciu CTRL+Shift+B.
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ę.
Wybierz pozycję Pobierz wszystkie osoby i sprawdź, czy twoje imię i nazwisko jest wyświetlane.
Poeksperymentuj, dodając więcej nazw i pobierając listę przechowywanych osób.
Wróć do programu Visual Studio lub Visual Studio Code i zatrzymaj debugowanie przy użyciu Shift+F5.
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ę.

Sprzężenie zwrotne

Czy ta strona była pomocna?