Dot.Blog | SQLite avec MAUI : Stockage de Données Locales

SQLite est une bibliothèque en C qui fournit une base de données légère sur disque sans nécessité d'un serveur séparé. C'est un choix populaire pour le stockage de données locales dans divers types d'application, notamment les applications mobiles. Dans ce post, nous allons examiner comment intégrer SQLite dans une application MAUI, en illustrant chaque étape avec des exemples de code en C# et XAML.

Pourquoi utiliser SQLite avec MAUI

Léger : SQLite est compact, occupant un espace mémoire minimal.
Facile à intégrer : Pas besoin de serveur de base de données séparé.
Portable : Compatible avec divers systèmes d'exploitation, ce qui convient parfaitement aux applications MAUI cross-platform.
Richesse de fonctionnalités : Il supporte un sous-ensemble substantiel du langage de requête SQL standard.

Installation du package NuGet SQLite

Pour commencer, installez le package NuGet SQLite-net-PCL dans votre projet MAUI. Vous pouvez le faire via le gestionnaire de package NuGet ou en exécutant la commande suivante :

dotnet add package SQLite-net-PCL

Attention, de façon temporaire, il est important d'installer un autre paquet Nuget pour que SQLite fonctionne, il s'agit de SQLitePCLRaw.bundle_green. On ne sait pas encore quand j'écris ces lignes combien de temps durera ce temporaire mais surveillez la doc officielle Microsoft pour vous tenir au courant ! Dans la pratique il n'y a pas d'ordre particulier à respecter entre les deux paquets, toutefois il semble logique d'ajouter le Raw Bundle Green en premier puis le nuget SQLite.

Initialisation de SQLite dans MAUI

Modèle de données

Créons d'abord une classe pour représenter notre modèle de données. Dans cet exemple, nous utiliserons une classe Person.

public class Person
{
    [PrimaryKey, AutoIncrement]
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

Initialisation de la base de données

Pour initialiser la base de données, créez une instance de SQLiteAsyncConnection.

public class Database
{
    readonly SQLiteAsyncConnection _database;
 
    public Database(string dbPath)
    {
        _database = 
          new SQLiteAsyncConnection(dbPath);
            _database.CreateTableAsync<Person>().Wait();
    }
}

Chemin de la base de données

Le chemin d'accès à la base de données dépend du système d'exploitation. Pour MAUI, vous pouvez obtenir le chemin comme suit :

string dbPath =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
"persons.db3");
Database database = new Database(dbPath);

Interaction avec la base de données

Insertion de données

Insérer un nouvel enregistrement dans la base de données :

public
Task<int> SavePersonAsync(Person person)
{
    return _database.InsertAsync(person);
}

Récupération de données

Récupérer tous les enregistrements de la table Person :

public
Task<List<Person>> GetPeopleAsync()
{
    return _database.Table<Person>().ToListAsync();
}

Mise à jour

Mettre à jour un enregistrement existant :

public
Task<int> UpdatePersonAsync(Person person)
{
    return _database.UpdateAsync(person);
}

Suppression

Supprimer un enregistrement :

public
Task<int> DeletePersonAsync(Person person)
{
    return _database.DeleteAsync(person);
}

Création et Utilisation d'un Service de Données

Service de Données

A la place de la classe Database, il est plus judicieux de créer un service de données qui encapsulera toutes les opérations CRUD. C'est une bonne pratique très utilisée. Le service peut être construit comme une classe statique, un Singleton Lazy, enregistré dans un moteur d'IoC pour faire de l'injection de dépendances…, autant de choses que je ne ferai pas voir ici (mais qu'on peut retrouver en détail dans mon "Guide Complet de .NET MAUI" en vente sur Amazon, en format broché ou Kindle).

public
class DataService
{
    readonly SQLiteAsyncConnection _database;
 
    public DataService(string dbPath)
    {
        _database = new SQLiteAsyncConnection(dbPath);
       _database.CreateTableAsync<Person>().Wait();
    }
 
    public Task<int>
AddPersonAsync(Person person)
    {
        return _database.InsertAsync(person);
    }
 
    public Task<List<Person>>
GetPeopleAsync()
    {
        return _database. Table<Person>().ToListAsync();
    }
 
    public Task<int>
UpdatePersonAsync(Person person)
    {
        return _database.UpdateAsync(person);
    }
 
    public Task<int>
DeletePersonAsync(Person person)
    {
        return _database.DeleteAsync(person);
    }
}

Utilisation dans une ViewModel

Intégrons ce service de données dans une ViewModel ce qui est le cas d'utilisation le plus courant.
Créons le ViewModel qui utilise notre DataService. Dans cet exemple, nous ajouterons une liste de personnes et des commandes pour ajouter et supprimer des personnes.

public
class PersonViewModel : INotifyPropertyChanged
{
    private List<Person> _people;
    public List<Person> People
    {
        get { return _people; }
        set
        {
            _people = value;
            OnPropertyChanged(nameof(People));
        }
    }
 
    public ICommand AddPersonCommand { get; }
    public ICommand DeletePersonCommand { get;
}
 
    private DataService _dataService;
 
    public PersonViewModel()
    {
        string dbPath =
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
"persons.db3");
        _dataService = new DataService(dbPath);
 
        AddPersonCommand = new Command(async ()
=> await AddPerson());
        DeletePersonCommand = new
Command<Person>(async (Person person) => await DeletePerson(person));
 
        LoadPeople();
    }
 
    public event PropertyChangedEventHandler PropertyChanged;
 
    private void
OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, 
          new PropertyChangedEventArgs(propertyName));
    }
 
    private async Task AddPerson()
    {
        Person newPerson = new Person { 
          Name = "John", Age = 30 };     
        await _dataService.AddPersonAsync(newPerson);
        LoadPeople();
    }
 
    private async Task DeletePerson(Person person)
    {
        await _dataService.DeletePersonAsync(person);
        LoadPeople();
    }
 
    private void LoadPeople()
    {
        People = _dataService.GetPeopleAsync().Result;
    }
}

Mise à jour de l'interface utilisateur (UI)

<ContentPage
xmlns="http://schemas.microsoft.com/dotnet/2021/maui"            
xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"            
x:Class="MyApp.MainPage">
    
<ContentPage.BindingContext>
       
<local:PersonViewModel />
    </ContentPage.BindingContext>
 
<StackLayout>
        <Button Text="Add Person" Command="{Binding AddPersonCommand}" />
        <Button Text="Delete Person" Command="{Binding DeletePersonCommand}" />
        <ListView ItemsSource="{Binding People}">
            <ListView.ItemTemplate>
                <DataTemplate>
                    <TextCell Text="{Binding Name}" Detail="{Binding Age}" />
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>
    </StackLayout>
</ContentPage>

Conclusion

SQLite s'intègre de manière transparente avec MAUI, offrant une solution robuste pour le stockage de données locales. Le package SQLite-net-PCL simplifie davantage le processus, permettant une interaction facile avec la base de données via le langage C#.

Dans cet exemple, nous avons également introduit un service de données pour encapsuler les opérations CRUD. Ce modèle rend notre architecture plus propre, plus modulaire et plus facile à maintenir, tout en étant conforme aux principes MVVM. Ce guide devrait vous fournir toutes les compétences nécessaires pour implémenter une solution de stockage de données locales solide dans vos applications MAUI, toutefois ce sujet est développé plus en profondeur et en utilisant la toolbox MVVM de MAUI dans mon ouvrage cité plus haut, les exemples de code de ce billet étant volontairement réduits.

Stay Tuned !

Le Guide Complet de.NET MAUI ! Lien direct Amazon : https://amzn.eu/d/95wBULD

Près de 500 pages dédiées à l'univers .NET MAUI !

Existe aussi en version Kindle à prix réduit !