📝 added SQLiteInMemory in providers section

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

@@ -0,0 +1,113 @@
+---
+sidebar_label: '5.5. SQLite In Memory'
+sidebar_position: 5
+description: "explique comment utiliser le fournisseur SQLite In Memory"
+---
+
+# Utilisation du fournisseur SQLite In Memory
+*02/02/2023 ⋅ Marc Chevaldonné*  
+
+---
+
+:::note base de données en mémoire
+Cette méthode utilise SQLite à travers une base de données directement en mémoire, et donc, non stockée.  
+Sa durée de vie est donc limitée à l'exécution du programme.  
+Cette méthode est donc préconisée pour des tests unitaires ou fonctionnels.
+:::  
+  
+*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
+- Microsoft.EntityFrameworkCore.SQLite
+
+### Code
+Dans votre classe héritant de ```DbContext```, utilisez la méthode d'extension ```UseSqlite```.  
+  
+```csharp MyDbContext
+public class MyDbContext : DbContext
+{
+    //...
+
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+    {
+        //...
+        var connection = new SqliteConnection("DataSource=:memory:");
+        connection.Open();
+        optionsBuilder.UseSqlite(connection);
+        //...
+    }
+}
+```
+
+De plus, au moment de l'instanciation de votre contexte, n'oubliez pas de vérifier ou de créer la base de données procéduralement de la manière suivante :
+```csharp Program.cs (ou tout autre endroit ou le contexte est initialisé)
+var context = new MyDbContext();
+await context.Database.EnsureCreatedAsync();
+```
+
+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
+Il n'est pas nécessaire de créer des migrations ou la table en utilisant les lignes de commande.
+
+## 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.  
+
+:::caution 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.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 connection = new SqliteConnection("DataSource=:memory:");
+connection.Open();
+var options = new DbContextOptionsBuilder<TheDbContext>()
+                    .UseSqlite(connection)
+                    .Options;
+var context = new TheDbContext(options);
+await context.Database.EnsureCreatedAsync();
+```
+
+* Les deux premières lignes permettent d'ouvrir une connexion de type Sqlite vers une base de données en mémoire en spécifiant la chaîne de connexion (```"DataSource=:memory:"```), spéciale pour SqliteInMemory.
+* La troisième crée les options en spécifiant le fournisseur ```UseSqlite``` et la connexion (donc le fait qu'on utilise SqliteInMemory).
+* La quatrième ligne crée le contexte en injectant ces options.
+* La cinquième ligne s'assure que la base de données est bien créée ou qu'elle existait déjà.
+
+:::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.
+:::