Entity Framework Core et SQLite dans une application Universelle Windows

10 minutes de lecture

La base de données embarquée SQLite est souvent utilisée lors du développement d’applications Universelles Windows (UW).

Pour gérer l’ensemble des flux entre l’application et la base de données SQLite, l’utilisation d’un mappeur relationnel objet (ORM) est envisageable.

Entity Framework Core est un ORM qui peut être utilisé avec SQLite sur une plateforme Windows Universelle (UWP) pour stocker et manipuler les données en base.

Cet article explique comment utiliser Entity Framework Core avec une base de données SQLite dans une application UW (XAML et C#).

L’approche utilisée dans cet article pour la génération de la base de données SQLite via Entity Framework Core est le Code First

Création d’un projet

  • Ouvrir Visual Studio 2017 (Dans notre cas il s’agit de Visual Studio 2017 Community)
  • Accéder au menu Fichier/ Nouveau / Projet.
  • Choisir une application vide de type Windows Universel. La nommer EntityFrameworkSample

Mise à jour du Microsoft.NETCore.UniversalWindowsPlatform

Entity Framework Core nécessite la version du Microsoft.NETCore.UniversalWindowsPlatform 5.2.2 ou ultérieur.

C’est pour cela que nous allons mettre à jour le Microsoft.NETCore.UniversalWindowsPlatform afin d’obtenir la toute dernière version. Pour ce faire :

  • Ouvrir la Console du Gestionnaire de package : Outils / Gestionnaire de package NuGet / Console du Gestionnaire de package.

  • Saisir la commande : Update-Package Microsoft.NETCore.UniversalWindowsPlatform et valider en appuyant sur la touche « Entrer ».

Installation d’Entity Framework

Avant d’utiliser Entity Framework Core avec SQLite il faut installer les packages Microsoft.EntityFrameworkCore.Sqlite et Microsoft.EntityFrameworkCore.Tools.

  • Ouvrir la Console du Gestionnaire de package : Outils / Gestionnaire de package NuGet / Console du Gestionnaire de package.
  • Saisir la commande : Install-Package Microsoft.EntityFrameworkCore.Sqlite.
  • Saisir la commande : Install-Package Microsoft.EntityFrameworkCore.Tools.

La solution doit contenir les références suivantes :

Création des modèles

  • Créer un dossier Models
  • Créer une classe : Post et la mettre dans le dossier Models

Voici son code:

Post

public class Post
{
public int PostId { get; set; }
public string Title { get; set; }
public string Content { get; set; }
}

Définition du contexte de la base de données (Database Context)

Le database context (DbContext) permet de définir la base de données qui sera utilisée ainsi que les tables associées.

  • Créer une classe
  • Rajouter l’espace de nom : Microsoft.EntityFrameworkCore.

Mettre le code suivant :

public class BloggingContext : DbContext
{
public DbSet<Post> Posts { get; set; }

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlite(« Data Source=blogging.db »);
}
}

La méthode OnConfiguring permet de spécifier le type de base de données qui sera utilisée. Dans notre cas, ce sera SQLite d’où optionsBuilder.UseSqlite.

Création de la base de données

Une fois que les modèles sont créés, nous pouvons utiliser la migration pour la création de la base de données SQLite.

  • Ouvrir la Console du Gestionnaire de package : Outils / Gestionnaire de package NuGet / Console du Gestionnaire de package.

Grâce au package Microsoft.EntityFrameworkCore.Tools installé en amont, nous pouvons utiliser un ensemble d’outils qui permettront de gérer la base de données SQLite. Notamment celui de la création de la base de données via la commande Add-Migration.

Cette commande permet de générer le fichier de code des modifications qui doivent être apportées à la base de données. Elle est toujours suivie du nom de la migration.

  • Saisir cette commande dans la console du gestionnaire de package : Add-Migration MyFirstMigration.

Dans notre cas, le nom de la migration est MyFirstMigration

Une fois la migration terminée, un dossier Migrations apparaît dans le projet.

Pour être sûr que lors du premier démarrage de l’application, la base de données sera créée, nous devons effectuer les étapes suivantes :

  • Clique droit dans le fichier App.xaml dans l’explorateur de solution et sélectionner Afficher le code.
  • Rajouter l’espace de nom EntityFrameworkCore dans le fichier App.xaml.cs
  • Dans le constructeur App, mettre le code suivant :

public App()
{
this.InitializeComponent();
this.Suspending += OnSuspending;

//Code à rajouter
using (var db = new BloggingContext())
{
db.Database.Migrate();
}
}

Ce code permet d’appliquer les migrations en attentes de la base de données.

  • Déployer et lancer l’application EntityFrameworkSample

En accédant au dossier LocalState du package de l’application, vous trouverez la base de données SQLite blogging.db

Vous avez la possibilité de voir son contenu en utilisant des outils tels que DB Browser for SQLite. Voir figure ci-dessous :

Manipulation des données de la base SQLite

Dans cette section, nous allons voir comment manipuler les données de la base de données SQLite en utilisant Entity Framework Core à travers un cas pratique.

Récupération des données

  • Ouvrir la page xaml et mettre le code suivant :

<Page
x:Class= »EntityFrameworkSample.MainPage »
xmlns= »http://schemas.microsoft.com/winfx/2006/xaml/presentation &raquo;
xmlns:x= »http://schemas.microsoft.com/winfx/2006/xaml &raquo;
xmlns:local= »using:EntityFrameworkSample »
xmlns:d= »http://schemas.microsoft.com/expression/blend/2008&Prime;
xmlns:mc= »http://schemas.openxmlformats.org/markup-compatibility/2006&Prime;
mc:Ignorable= »d »
Loaded= »Page_Loaded »>

<Grid Background= »{ThemeResource ApplicationPageBackgroundThemeBrush} »>
<Grid.ColumnDefinitions>
<ColumnDefinition Width= »2* » />
<ColumnDefinition Width= »* » />
</Grid.ColumnDefinitions>

<!–LISTE DES POSTES–>
<ListView x:Name= »LVPostes »
Margin= »5″>
<ListView.ItemTemplate>
<DataTemplate>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width= »* » />
<ColumnDefinition Width= »4* » />
</Grid.ColumnDefinitions>

<!–ID–>
<Grid Background= »DarkGreen »>
<TextBlock HorizontalAlignment= »Center »
VerticalAlignment= »Center » Foreground= »White »
Text= »{Binding PostId} »
Style= »{StaticResource HeaderTextBlockStyle} » />
</Grid>

<!–Post–>
<StackPanel Grid.Column= »1″ Margin= »5″ VerticalAlignment= »Center » HorizontalAlignment= »Center »>
<TextBlock Style= »{StaticResource SubheaderTextBlockStyle} »
Foreground= »DarkGreen »
Text= »{Binding Title} » />
<TextBlock Foreground= »Black » TextTrimming= »None » TextWrapping= »WrapWholeWords »
Text= »{Binding Content} »
Margin= »0 5 0 5″ />
</StackPanel>
</Grid>
</DataTemplate>
</ListView.ItemTemplate>
<ListView.ItemContainerStyle>
<Style TargetType= »ListViewItem »>
<Setter Property= »Margin »
Value= »0 5 0 0″ />
<Setter Property= »Padding »
Value= »0 0 5 0″ />
<Setter Property= »HorizontalContentAlignment »
Value= »Stretch » />

</Style>
</ListView.ItemContainerStyle>
</ListView>

</Grid>
</Page>

Ouvrir la page MainPage.xaml.cs et mettre le code suivant :

/// <summary>
/// Une page vide peut être utilisée seule ou constituer une page de destination au sein d’un frame.
/// </summary>
public sealed partial class MainPage : Page
{
public MainPage()
{
this.InitializeComponent();
}

private void Page_Loaded(object sender, RoutedEventArgs e)
{
using (var db = new BloggingContext())
{
//Permet de récupérer les données de la table Posts
LVPostes.ItemsSource = db.Posts.ToList();
}
}
}

Il est possible d’utiliser des requêtes LINQ pour exploiter les données de la base de données SQLite. Dans ce cas-là, il faut éviter d’utiliser des données de types anonymes.

Insertion et suppression de données

En dessous de la ListView LVPostes du fichier MainPage.xaml mettre le code XAML suivant :

<!–SAISIR UN POSTE–>
<RelativePanel Grid.Column= »1″
HorizontalAlignment= »Center »
VerticalAlignment= »Center »>
<TextBlock x:Name= »LblPost »
Text= »Post »
Foreground= »DarkGreen »
Margin= »0 0 0 10″
Style= »{StaticResource SubheaderTextBlockStyle} » />
<TextBox x:Name= »TxtTitle » PlaceholderText= »Titre »
RelativePanel.Below= »LblPost »
Foreground= »DarkGreen »
BorderBrush= »DarkGreen »
BorderThickness= »1″
Width= »400″ />

<TextBox RelativePanel.Below= »TxtTitle » PlaceholderText= »Contenu »
Margin= »0 10 0 0″ x:Name= »TxtContent »
Foreground= »DarkGreen »
BorderBrush= »DarkGreen »
BorderThickness= »1″
AcceptsReturn= »True »
Width= »400″
Height= »200″
ScrollViewer.HorizontalScrollBarVisibility= »Disabled »
ScrollViewer.HorizontalScrollMode= »Disabled »
ScrollViewer.VerticalScrollBarVisibility= »Auto »
ScrollViewer.VerticalScrollMode= »Auto » />
<Button Background= »DarkGreen »
Width= »190″ x:Name= »BtnAjouter »
Content= »Ajouter » Tapped= »BtnAjouter_Tapped »
Foreground= »White »
RelativePanel.Below= »TxtContent »
Margin= »0 10 0 0″ />
<Button Background= »DarkRed »
Width= »190″ x:Name= »BtnSupprimer » Tapped= »BtnSupprimer_Tapped »
Foreground= »White »
Content= »Supprimer »
RelativePanel.RightOf= »BtnAjouter »
RelativePanel.AlignTopWith= »BtnAjouter »
Margin= »20 10 0 0″ />
</RelativePanel>

Accéder au fichier MainPage.xaml.cs et rajouter le code suivant :

/// <summary>
/// Suppression d’un post
/// </summary>
/// <param name= »sender »></param>
/// <param name= »e »></param>
private void BtnSupprimer_Tapped(object sender, TappedRoutedEventArgs e)
{

Post post =(Post) LVPostes.SelectedItem;

if (post!=null)
{
using (var db = new BloggingContext())
{
//Suppression du post dans la base de données
db.Remove(post);
db.SaveChanges();
LVPostes.ItemsSource = db.Posts.ToList();
}
}

}

/// <summary>
/// Ajouter un post
/// </summary>
/// <param name= »sender »></param>
/// <param name= »e »></param>
private void BtnAjouter_Tapped(object sender, TappedRoutedEventArgs e)
{
using (var db = new BloggingContext())
{
Post post = new Post
{
Title = TxtTitle.Text,
Content = TxtContent.Text

};

//Ajout du post en base de données
db.Posts.Add(post);
db.SaveChanges();

LVPostes.ItemsSource = db.Posts.ToList();
}
TxtTitle.Text = String.Empty;
TxtContent.Text = String.Empty;
}

Voili voilou ! 🙂

Si vous avez un compte twitter, n’hésitez pas à me suivre : @NordineMhoumadi

Source : https://docs.microsoft.com/fr-fr/windows/uwp/data-access/entity-framework-7-with-sqlite-for-csharp-apps

Publicités