Exercice : Stocker des données localement avec SQLite

15 minutes

Dans cet exercice, vous allez utiliser SQLite pour stocker des informations localement avec une application. Dans l’exemple de scénario, vous avez décidé de mettre en cache des données pour l’application de médias sociaux afin d’en améliorer la réactivité. Cet exercice crée et utilise une base de données SQLite locale pour stocker des informations sur les personnes. Vous allez enregistrer le fichier de base de données physique dans le stockage local.

Ce module utilise le kit de développement logiciel (SDK) .NET 8.0. Assurez-vous que .NET 8.0 est installé en exécutant la commande suivante dans votre terminal de commandes préféré :

dotnet --list-sdks

Une sortie semblable à l’exemple suivant s’affiche :

6.0.317 [C:\Program Files\dotnet\sdk]
7.0.401 [C:\Program Files\dotnet\sdk]
8.0.100 [C:\Program Files\dotnet\sdk]

Vérifiez que la liste comporte une version commençant par 8. S’il n’y en a pas ou que la commande est introuvable, installez la dernière version du kit de développement logiciel (SDK) .NET 8.0.

Ouvrir la solution de démarrage

Clonez ou téléchargez le dépôt des exercices.

Remarque

Il est préférable de cloner le contenu de l’exercice dans un chemin de dossier court, tel que C:\dev, pour éviter que les fichiers générés par la build dépassent la longueur maximale de chemin.
Utilisez Visual Studio pour ouvrir la solution People.sln, que vous trouverez dans mslearn-dotnetmaui-store-local-data>Personnes, ou dans le dossier de démarrage dans Visual Studio Code.

Remarque

N’essayez pas encore de créer la solution. Le code est incomplet. IL ne sera pas compilé tant que vous n’aurez pas ajouté les éléments manquants plus loin dans cet exercice.

Définir une entité SQLite

Cliquez avec le bouton droit sur le projet Personnes, sélectionnez Ajouter, puis sélectionnez Nouveau dossier pour ajouter un nouveau dossier au projet. Nommez ce nouveau dossier Modèles.
Cliquez avec le bouton droit sur le dossier Modèles et sélectionnez Ajouter, puis Nouvelle classe. Vérifiez que la Classe est sélectionnée dans la liste, puis nommez la nouvelle classe Person.cs. Sélectionnez Ajouter.

Modifiez la classe et marquez-la comme public :

namespace People.Models;

public class Person
{
}

Ajoutez une propriété int appelée Id à la classe Person.

Une propriété string appelée Name. La classe doit ressembler à cela :

namespace People.Models;

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

Enregistrez le fichier Person.cs.

Ajouter la bibliothèque SQLite

Cliquez avec le bouton droit sur le nœud du projet People à partir de l’Explorateur de solutions dans Visual Studio.
Dans le menu contextuel qui s’affiche, sélectionnez Gérer les packages NuGet.
Recherchez et sélectionnez sqlite-net-pcl, puis Installer.
Recherchez et sélectionnez également SQLitePCLRaw.bundle_green, puis sélectionnez Installer.

Si vous utilisez Visual Studio Code, ouvrez le terminal et ces packages à l’aide des commandes suivantes :

dotnet add package sqlite-net-pcl
dotnet add package SQLitePCLRaw.bundle_green

Ajouter des attributs SQLite

Dans le ficher Person.cs, ajoutez une directive using pour l’espace de noms SQLite au fichier de la classe Person. Cette directive vous permet d’utiliser les attributs SQLite.
```
using SQLite;

namespace People.Models;

public class Person
{
    ...
}
```
Annotez la classe Person avec l’attribut [Table] et spécifiez people comme nom de table.
Spécifiez la propriété Id comme clé primaire. Annotez-la avec les attributs [PrimaryKey] et [AutoIncrement].

Ajoutez des annotations à la propriété Name. Spécifiez sa valeur MaxLength comme 250. Spécifiez que chaque valeur de la colonne doit être Unique.

Une fois terminée, la classe devrait se présenter comme suit :

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

Enregistrez le fichier Person.cs.

Se connecter à la base de données

Ouvrez le fichier PersonRepository.cs.
Examiner la classe PersonRepository. Cette classe contient du code squelette incomplet avec des marqueurs TODO dans lesquels vous allez ajouter les fonctionnalités permettant d’accéder à la base de données.
Ajoutez une directive using pour les espaces de noms SQLite et People.Models au fichier de la classe PersonRepository.cs.
Ajoutez un champ SQLiteConnection privé nommé conn à la classe, au-dessus de la fonction Init.
Dans la fonction Init, vérifiez que conn n’est pas égal à null. Si c’est le cas, retournez immédiatement.
```
if (conn != null)
    return;
```
De cette façon, le code d’initialisation de la base de données SQLite ne s’exécute qu’une seule fois.
Initialisez le champ conn pour vous connecter à la base de données en utilisant la variable _dbPath.

Utilisez la méthode conn.CreateTable pour créer une table afin de stocker des données Person. Une fois terminée, la fonction Init devrait ressembler à ceci :

using SQLite;
using People.Models;
...

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

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

Insérer une ligne dans la base de données

Dans la classe PersonRepository, recherchez la méthode AddNewPerson.

Remplacez le commentaire TODO dans cette méthode par du code pour insérer un nouvel objet Person. Le code appelle Init d’abord pour vérifier que la base de données est initialisée, puis utilise la méthode SQLiteConnection de l’objet Insert. Définissez la variable result sur la valeur que la méthode Insert renvoie, comme indiqué dans le code suivant :

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

Récupérer des lignes de la base de données

Dans la classe PersonRepository, recherchez la méthode GetAllPeople.
Appelez Init pour vérifier que la base de données a été initialisée.
Utilisez la méthode Table\<T> générique pour récupérer toutes les lignes de la table. Spécifiez Person comme paramètre de type.
Utilisez la méthode d’extension ToList() pour convertir le résultat en collection List\<Person> et retournez cette collection.
Ajoutez une gestion des erreurs en wrappant votre code dans un bloc try-catch. En cas d’erreur, définissez la propriété StatusMessage sur la propriété Message de l’exception et retournez une collection vide. Une fois terminée, la méthode devrait ressembler à ceci :
```
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>();
}
```
Enregistrez le fichier PersonRepository.cs.

Intégrer le référentiel à l’interface utilisateur

Ouvrez le fichier MauiProgram.cs.
Dans la fonction CreateMauiApp, après les instructions qui ajoutent la page MainPage en tant que service singleton à l’application, ajoutez du code pour effectuer les tâches suivantes :
- Créez une variable de chaîne nommée dbPath. Initialisez cette chaîne avec l’expression FileAccessHelper.GetLocalFilePath("people.db3"). Le fichier de base de données utilisé par l’application est appelé people.db3 et l’application enregistre ce fichier dans un stockage local sur l’appareil.
- Utilisez l’injection de dépendances pour ajouter la classe PersonRepository en tant que service singleton à l’application. La classe PersonRepository expose un constructeur qui prend le chemin du fichier de base de données en tant que paramètre de chaîne.
Le code terminé pour la fonction CreateMauiApp devrait ressembler à ceci :
```
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();
}
```
Enregistrez le fichier MauiProgram.cs.
Développez App.xaml dans l’Explorateur de solutions, puis ouvrez le fichier App.xaml.cs.
Ajoutez une propriété public, static appelée PersonRepo pour conserver un objet PersonRepository dans la classe App.
Initialisez la propriété PersonRepo dans le constructeur en ajoutant un paramètre PersonRepository au constructeur et en définissant la propriété « PersonRepo » sur la valeur de ce paramètre. Une fois terminée, la classe App devrait ressembler à ce qui suit :
```
public partial class App : Application
{
    public static PersonRepository PersonRepo { get; private set; }

    public App(PersonRepository repo)
    {
        InitializeComponent();

        MainPage = new AppShell();

        PersonRepo = repo;
    }
}
```

Remarque

Le processus d’injection de dépendances renseigne automatiquement le paramètre repo dans le constructeur.

Test de l’application

Générez la solution en utilisant Ctrl+Maj+B et démarrez le débogage en utilisant F5. Lorsque l’interface utilisateur s’affiche, entrez votre nom et sélectionnez Ajouter une personne.
Sélectionnez Obtenir toutes les personnes et vérifiez que votre nom s’affiche.
Essayez en ajoutant d’autres noms et en récupérant la liste des personnes stockées.
Revenez à Visual Studio ou Visual Studio Code et arrêtez le débogage en utilisant le raccourci clavier Maj+F5.
Redémarrez l’application et sélectionnez Obtenir toutes les personnes. Vérifiez que les noms que vous avez stockés précédemment sont toujours stockés dans la base de données. Fermez l’application une fois que vous avez terminé.

Continuer