wip

Correction/ReadMe.md

@@ -261,9 +261,7 @@ Même à l’échelle d’un mini-jeu console, cette architecture permet :
 * une application concrète des principes **SOLID**
 * une implémentation claire de l’**architecture hexagonale**
 
-> *Ps:*<br/>
-> On a donc utilisé un canon pour écraser une mouche, mais au moins, on sait comment fonctionne le canon!<br/>
-> Et oui, c'est excessif pour un jeu en console. Non, on ne regrette rien. L'apprentissage n'a pas de prix (mais a beaucoup de classes).
+> *Ps:* On a donc utilisé un canon pour écraser une mouche, mais au moins, <br/> on sait comment fonctionne le canon !
 
 ---
 

modernStyleC8-12.md

@@ -0,0 +1,220 @@
+Bien sûr 🙂
+Voici une **petite liste d’exemples de styles modernes en C# (C# 8 → C# 12)**, avec des cas courants : conditions, parcours de tableaux, création d’objets, etc.
+
+---
+
+## 🔹 1. Opérateur ternaire (version concise)
+
+```csharp
+string status = string.Empty;
+If(age >= 18)
+{
+    statut = "Majeur"
+} 
+else 
+{
+    statut = "Mineur"
+}
+
+// ou
+var statut = age >= 18 ? "Majeur" : "Mineur";
+```
+
+Avec expression conditionnelle imbriquée :
+
+```csharp
+var note = score switch
+{
+    >= 16 => "Très bien",
+    >= 12 => "Bien",
+    >= 10 => "Passable",
+    _ => "Insuffisant"
+};
+```
+
+---
+
+## 🔹 2. `switch` expression (moderne)
+
+```csharp
+string message = codeErreur switch
+{
+    404 => "Introuvable",
+    401 => "Non autorisé",
+    500 => "Erreur serveur",
+    _   => "Erreur inconnue"
+};
+```
+
+---
+
+## 🔹 3. Parcourir un tableau / liste
+
+### `foreach` (simple et propre)
+
+```csharp
+foreach (var item in items)
+{
+    Console.WriteLine(item);
+}
+```
+
+### LINQ (fonctionnel)
+
+```csharp
+items
+    .Where(i => i.IsActive)
+    .Select(i => i.Name)
+    .ToList()
+    .ForEach(Console.WriteLine);
+```
+
+---
+
+## 🔹 4. Création d’objet (init rapide)
+
+### Initialiseur d’objet
+
+```csharp
+var user = new User
+{
+    Id = 1,
+    Name = "Alice",
+    IsAdmin = true
+};
+```
+
+### Constructeur concis (target-typed `new`)
+
+```csharp
+User user = new(1, "Alice", true);
+```
+
+---
+
+## 🔹 5. `record` (objets immuables – très moderne)
+
+```csharp
+public record User(int Id, string Name, bool IsAdmin);
+```
+
+Utilisation :
+
+```csharp
+// User(int id, string name, bool isAdmin)
+var user = new User(1, "Alice", false);
+// Retourn false.
+var admin = user with { IsAdmin = true };
+```
+
+---
+
+## 🔹 6. Null safety (très utilisé)
+
+### Opérateur `?.`
+
+```csharp
+// Si user == null alors on n'accède pas à Name
+// Si Name == null alors on n'accède pas à Length
+var length = user?.Name?.Length;
+```
+
+### Coalescence `??`
+
+```csharp
+// Si user.Name == null alors on assigne "Inconnu"
+string name = user.Name ?? "Inconnu";
+```
+
+### Affectation conditionnelle `??=`
+
+```csharp
+// Si null alors on assigne.
+user.Name ??= "Par défaut";
+```
+
+---
+
+## 🔹 7. Expressions lambda
+
+```csharp
+Func<int, int> carre = x => x * x;
+Console.WriteLine(carre(5));
+```
+
+---
+
+## 🔹 8. Pattern matching
+
+```csharp
+if (obj is User { IsAdmin: true })
+{
+    Console.WriteLine("Admin détecté");
+}
+```
+
+---
+
+## 🔹 9. Tableaux et collections modernes
+
+### Création simplifiée (C# 9+)
+
+```csharp
+int[] nombres = { 1, 2, 3, 4 };
+```
+
+### Range & Index
+
+```csharp
+int[] nombres = { 1, 2, 3, 4, 5 };
+
+// INDEX (^) – à partir de la fin
+var ... = nombres[^1];           // dernier élément → 5
+var ... = nombres[^2];           // avant-dernier → 4
+var ... = nombres[^3];           // retourne 3
+
+// RANGE (..) – sous-tableaux
+var ... = nombres[1..4];         // {2, 3, 4}
+// Un seul élément via Range
+var ... = nombres[2..3];         // {3}
+// Début → Fin du tableau
+var ... = nombres[2..];          // {3, 4, 5}
+// Début du tableau → Fin
+var ... = nombres[..3];          // {1, 2, 3}
+// Début → Fin (exclus)
+var sousTableau = nombres[1..4]; // {2, 3, 4}
+// Tout le tableau
+var ... = nombres[..];           // {1, 2, 3, 4, 5}
+// Range avec Index depuis la fin
+var ... = nombres[1..^1];        // {2, 3, 4}
+// Derniers éléments
+var ... = nombres[^2..];         // {4, 5}
+// Tout sauf les deux derniers
+var ... = nombres[..^2];         // {1, 2, 3}
+```
+
+---
+
+## 🔹 10. Méthodes d’expression (très clean)
+
+```csharp
+int Add(int a, int b) => a + b;
+```
+
+---
+
+## 🔹 11. `using` moderne (sans bloc)
+
+```csharp
+using var file = new StreamWriter("test.txt");
+file.WriteLine("Hello");
+```
+
+---
+
+## 🔹 12. Collections immuables rapides
+
+```csharp
+// Création d'un tableau de string
+var fruits = new[] { "Pomme", "Banane", "Orange" };
+```

readme.md

@@ -158,4 +158,6 @@ private int Write(int value){
     return value + 1;
 }
 
-```
+```
+
+Pour aller plus loins: [ici](./modernStyleC8-12.md)