update Sqlite, Postgres, Mariadb providers

Documentation/docusaurus/docs/Entity-Framework/Providers/Mariadb.mdx

@@ -4,7 +4,6 @@ sidebar_position: 3
 description: "explique comment utiliser le fournisseur MariaDB"
 ---
 
-
 # Utilisation du fournisseur MariaDB
 *01/02/2023 ⋅ Marc Chevaldonné*  
 
@@ -44,13 +43,18 @@ docker exec -it mdb mariadb --user root -pPassword123!
 Le root password donné juste après le ```-p``` est celui défini dans la commande ```docker run```.
 :::
 
-## NuGet
+*Utilisez l'une ou l'autre des 2 méthodes suivantes.*  
+
+## Méthode 1 : en modifiant une classe fille de ```DbContext```
+Il faut d'abord modifier du code, puis lancer les commandes de migration et de création de la base de données.
+
+### NuGet
 Depuis Visual Studio (mac ou windows), installez les packages NuGet suivants, dans le projet contenant votre ```DbContext``` et vos entités :
 - Microsoft.EntityFrameworkCore
 - Microsoft.EntityFrameworkCore.Tools
 - Pomelo.EntityFrameworkCore.MySql
 
-## DbContext
+### Code
 Dans votre classe héritant de DbContext, utilisez la méthode d'extension ```UseMySql```.  
   
 ```csharp MyDbContext
@@ -73,10 +77,67 @@ Vous devez bien sûr utiliser les variables définies lors de la commande ```doc
 
 Pour le reste de votre projet EntityFrameworkCore, aucune différence avec les méthodes présentées précédemment.
 
-## Migrations et création de la base de données
+### Migrations et création de la base de données
 Vous pouvez maintenant créer les migrations et la base de données à l'aide des commandes classiques
 (par exemple depuis le projet dans lequel se trouve votre classe héritant de ```DbContext````) :
 ```
 dotnet ef migrations add myMigrationName
 dotnet ef database update
-```
+```
+
+## Méthode 2 : injection de ```DbContextOptions```
+Cette méthode permet d'utiliser une classe héritant de ```DbContext``` (```TheDbContext``` par exemple) sans en changer le code.  
+
+:::warning Condition sur ```OnConfiguring```
+Il faut néanmoins que la classe fille de ```DbContext``` (par exemple ```TheDbContext```) :
+1. possède un constructeur permettant de passer un ```DbContextOptions``` en paramètre.
+```csharp TheDbContext
+public TheDbContext(DbContextOptions<TheDbContext> options)
+    : base(options)
+{
+}
+```
+2. n'impose pas un fournisseur et une chaîne de connexion dans la méthode OnConfiguring, 
+par exemple à l'aide d'un ```if(!optionsBuilder.IsConfigured)```
+```csharp TheDbContext
+protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+{
+    if(!optionsBuilder.IsConfigured)
+    {
+        optionsBuilder.Use...(...);
+    }
+}
+```
+:::
+
+### NuGet
+Depuis Visual Studio (mac ou windows), installez les packages NuGet suivants, dans le projet contenant votre ```DbContext``` et vos entités
+(cela devrait déjà être fait si vous vous injectez un nouveau fournisseur dans un ```DbContext``` existant déjà) :
+- Microsoft.EntityFrameworkCore
+- Microsoft.EntityFrameworkCore.Tools  
+  
+Puis installez le package Nuget suivant dans le projet qui contiendra la création des options et l'injection dans le contexte 
+(le projet de démarrage par exemple) :
+- Pomelo.EntityFrameworkCore.MySql
+
+### Code
+On peut dès lors, avant la création du contexte, créer des options permettant de choisir le fournisseur de la manière suivante :
+```csharp Program.cs (ou autre)
+var options = new DbContextOptionsBuilder<ArtistsDbContext>()
+                    .UseMySql("server=localhost;port=3306;user=user;password=pwd;database=mydb", new MySqlServerVersion(new Version(10, 11, 1)))
+                    .Options;
+var context = new TheDbContext(options); //ou une autre classe dérivant de TheDbContext
+await context.Database.EnsureCreatedAsync(); //pour créer la base si elle n'existe pas déjà
+```
+
+* La première ligne permet de choisir les options, dont le fournisseur (```UseMySql```) et la chaîne de connexion (```"server=localhost;port=3306;user=user;password=pwd;database=mydb"```).
+* La deuxième ligne crée le contexte en injectant ces options.
+* La troisième ligne s'assure que la base de données est bien créée ou qu'elle existait déjà.
+
+:::note variables
+Vous devez bien sûr utiliser les variables définies lors de la commande ```docker run```, ou les variables par défaut si vous ne les avez pas définies.
+:::
+
+:::note migrations ?
+Avec cette méthode, il n'est pas nécessaire de créer les migrations ou la base de données en lignes de commande.
+:::

Documentation/docusaurus/docs/Entity-Framework/Providers/Postgres.mdx

@@ -4,7 +4,6 @@ sidebar_position: 2
 description: "explique comment utiliser le fournisseur Postgres"
 ---
 
-
 # Utilisation du fournisseur Postgres
 *01/02/2023 ⋅ Marc Chevaldonné*  
 
@@ -31,13 +30,18 @@ docker run --rm -P -p 127.0.0.1:5432:5432 -e POSTGRES_PASSWORD="1234" --name pg
 N'hésitez pas à changer les variables d'environnement comme le password, le user id, le nom de la database...
 :::
 
-## NuGet
+*Utilisez l'une ou l'autre des 2 méthodes suivantes.*  
+
+## Méthode 1 : en modifiant une classe fille de ```DbContext```
+Il faut d'abord modifier du code, puis lancer les commandes de migration et de création de la base de données.
+
+### NuGet
 Depuis Visual Studio (mac ou windows), installez les packages NuGet suivants, dans le projet contenant votre ```DbContext``` et vos entités :
 - Microsoft.EntityFrameworkCore
 - Microsoft.EntityFrameworkCore.Tools
 - Npgsql.EntityFrameworkCore.PostgreSQL
 
-## DbContext
+### Code
 Dans votre classe héritant de DbContext, utilisez la méthode d'extension ```UseNpgsql```.  
   
 ```csharp MyDbContext
@@ -60,10 +64,67 @@ Vous devez bien sûr utiliser les variables définies lors de la commande ```doc
 
 Pour le reste de votre projet EntityFrameworkCore, aucune différence avec les méthodes présentées précédemment.
 
-## Migrations et création de la base de données
+### Migrations et création de la base de données
 Vous pouvez maintenant créer les migrations et la base de données à l'aide des commandes classiques
 (par exemple depuis le projet dans lequel se trouve votre classe héritant de ```DbContext````) :
 ```
 dotnet ef migrations add myMigrationName
 dotnet ef database update
-```
+```
+
+## Méthode 2 : injection de ```DbContextOptions```
+Cette méthode permet d'utiliser une classe héritant de ```DbContext``` (```TheDbContext``` par exemple) sans en changer le code.  
+
+:::warning Condition sur ```OnConfiguring```
+Il faut néanmoins que la classe fille de ```DbContext``` (par exemple ```TheDbContext```) :
+1. possède un constructeur permettant de passer un ```DbContextOptions``` en paramètre.
+```csharp TheDbContext
+public TheDbContext(DbContextOptions<TheDbContext> options)
+    : base(options)
+{
+}
+```
+2. n'impose pas un fournisseur et une chaîne de connexion dans la méthode OnConfiguring, 
+par exemple à l'aide d'un ```if(!optionsBuilder.IsConfigured)```
+```csharp TheDbContext
+protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+{
+    if(!optionsBuilder.IsConfigured)
+    {
+        optionsBuilder.Use...(...);
+    }
+}
+```
+:::
+
+### NuGet
+Depuis Visual Studio (mac ou windows), installez les packages NuGet suivants, dans le projet contenant votre ```DbContext``` et vos entités
+(cela devrait déjà être fait si vous vous injectez un nouveau fournisseur dans un ```DbContext``` existant déjà) :
+- Microsoft.EntityFrameworkCore
+- Microsoft.EntityFrameworkCore.Tools  
+  
+Puis installez le package Nuget suivant dans le projet qui contiendra la création des options et l'injection dans le contexte 
+(le projet de démarrage par exemple) :
+- Npgsql.EntityFrameworkCore.PostgreSQL
+
+### Code
+On peut dès lors, avant la création du contexte, créer des options permettant de choisir le fournisseur de la manière suivante :
+```csharp Program.cs (ou autre)
+var options = new DbContextOptionsBuilder<ArtistsDbContext>()
+                    .UseNpgsql(@"host=localhost;database=postgres;user id=postgres;password=1234;")
+                    .Options;
+var context = new TheDbContext(options); //ou une autre classe dérivant de TheDbContext
+await context.Database.EnsureCreatedAsync(); //pour créer la base si elle n'existe pas déjà
+```
+
+* La première ligne permet de choisir les options, dont le fournisseur (```UseNpgsql```) et la chaîne de connexion (```"host=localhost;database=postgres;user id=postgres;password=1234;"```).
+* La deuxième ligne crée le contexte en injectant ces options.
+* La troisième ligne s'assure que la base de données est bien créée ou qu'elle existait déjà.
+
+:::note variables
+Vous devez bien sûr utiliser les variables définies lors de la commande ```docker run```, ou les variables par défaut si vous ne les avez pas définies.
+:::
+
+:::note migrations ?
+Avec cette méthode, il n'est pas nécessaire de créer les migrations ou la base de données en lignes de commande.
+:::

Documentation/docusaurus/docs/Entity-Framework/Providers/SQLite.mdx

@@ -13,17 +13,18 @@ description: "explique comment utiliser le fournisseur SQLite"
 Cette méthode utilise SQLite à travers une base de données dans un fichier local.  
 Pour explorer le contenu de la base, vous pouvez utiliser un logiciel comme [**DB Browser for SQLite**](https://sqlitebrowser.org/dl/)
 :::  
+  
+*Utilisez l'une ou l'autre des 2 méthodes suivantes.*  
+
+## Méthode 1 : en modifiant une classe fille de ```DbContext```
+Il faut d'abord modifier du code, puis lancer les commandes de migration et de création de la base de données.
 
-## NuGet
+### NuGet
 Depuis Visual Studio (mac ou windows), installez les packages NuGet suivants, dans le projet contenant votre ```DbContext``` et vos entités :
 - Microsoft.EntityFrameworkCore
 - Microsoft.EntityFrameworkCore.Tools
 - Microsoft.EntityFrameworkCore.SQLite
-  
-*Utilisez ensuite l'une ou l'autre des 2 méthodes suivantes.*  
 
-## Méthode 1 : en modifiant une classe fille de ```DbContext```
-Il faut d'abord modifier du code, puis lancer les commandes de migration et de création de la base de données.
 ### Code
 Dans votre classe héritant de DbContext, utilisez la méthode d'extension ```UseSqlite```.  
   
@@ -93,6 +94,17 @@ protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
 ```
 :::
 
+### NuGet
+Depuis Visual Studio (mac ou windows), installez les packages NuGet suivants, dans le projet contenant votre ```DbContext``` et vos entités
+(cela devrait déjà être fait si vous vous injectez un nouveau fournisseur dans un ```DbContext``` existant déjà) :
+- Microsoft.EntityFrameworkCore
+- Microsoft.EntityFrameworkCore.Tools  
+  
+Puis installez le package Nuget suivant dans le projet qui contiendra la création des options et l'injection dans le contexte 
+(le projet de démarrage par exemple) :
+- Npgsql.EntityFrameworkCore.Sqlite
+
+### Code
 On peut dès lors, avant la création du contexte, créer des options permettant de choisir le fournisseur de la manière suivante :
 ```csharp Program.cs (ou autre)
 var options = new DbContextOptionsBuilder<TheDbContext>().UseSqlite($"Data Source=LeNomDe.MaBase.db").Options;