Exercice : Stocker des données localement avec SQLite

15 minutes

Dans cet exercice, vous utilisez 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 enregistrez le fichier de base de données physique dans le stockage local.

Ce module utilise le Kit de développement logiciel (SDK) .NET 10.0. Vérifiez que .NET 10.0 est installé en exécutant la commande suivante dans votre terminal de commande préféré :

dotnet --list-sdks

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

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

Vérifiez que la liste comporte une version commençant par 10. Si aucune liste n’est répertoriée ou que la commande n’est pas trouvée, installez le kit SDK .NET 10.0 le plus récent.

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, qui se trouve dans mslearn-dotnetmaui-store-local-data>Personnes ou dans le dossier de démarrage de Visual Studio Code.

Remarque

N’essayez pas encore d’exécuter l’application. En effet, le code est incomplet et lève des exceptions jusqu’à ce que vous ajoutiez les éléments manquants plus loin dans cet exercice.

Définir une entité SQLite

Ouvrez le fichier Person.cs dans le dossier Models.
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.

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

dotnet add package sqlite-net-pcl

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 ajoutez 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 si 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.

Pour insérer un nouvel objet Person, remplacez le commentaire TODO dans cette méthode par du code. 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 est 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. Cette propriété contient un objet PersonRepository à 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();
        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 appuyant sur CTRL+Maj+B.
Une fois la génération terminée, 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é.

Commentaires

Cette page a-t-elle été utile ?