update to .NET6

p02_Fondamentaux/ex_003_001_Main/Program.cs

@@ -0,0 +1,31 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-21
+//
+// ========================================================================
+
+// le point d'entrée d'une application Console est la fonction Main (statique) d'une classe quelconque 
+// que Visual Studio nomme par défaut Program, et qu'il place automatiquement dans l'espace de noms
+// portant  le même nom que le projet. Vous pouvez changer le nom de la classe et l'espace de noms.
+namespace ex_003_001_Main
+{
+    class Program
+    {
+        /// <summary>
+        /// En C#, tous les objets dérivent de la classe object, et tout est objet.
+        /// En conséquence, la fonction Main doit être dans une classe (ici la classe Program).
+        /// La fonction Main est le point d'entrée du programme. Elle est statique pour pouvoir
+        /// être appelée sans que Program soit instancié. Ce n'est pas important si ceci n'est pas 
+        /// encore clair pour vous, à ce moment-là du cours.
+        /// </summary>
+        static void Main()
+        {
+        }
+    }
+}
+

p02_Fondamentaux/ex_003_001_Main/ex_003_001_Main.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_003_001_Main</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_003_001_Main</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_003_002_Main_HelloWorld/Program.cs

@@ -0,0 +1,27 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-21
+//
+// ========================================================================
+
+//Ici, nous avons besoin de using System; car la classe Console est dans l'espace de noms System.
+using System;
+using static System.Console;
+
+//Ce programme affiche "Coucou le monde !" dans la console.
+namespace ex_003_002_Main_HelloWorld
+{
+    class Program
+    {
+        //aucun argument
+        static void Main()
+        {
+            WriteLine("Coucou le monde !");
+        }
+    }
+}

p02_Fondamentaux/ex_003_002_Main_HelloWorld/ex_003_002_Main_HelloWorld.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_003_002_Main_HelloWorld</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_003_002_Main_HelloWorld</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_003_003_Main_arguments/Program.cs

@@ -0,0 +1,41 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-21
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_003_003_Main_arguments
+{
+    class Program
+    {
+        //les arguments sont passés dans un tableau de chaîne de caractères
+        static void Main(string[] args)
+        {
+            Console.OutputEncoding = System.Text.Encoding.UTF8;
+
+            WriteLine("Coucou le monde !");
+
+            //on peut en savoir le nombre en utilisant la propriété Length
+            //ici, {0} sera remplacé par la valeur de args.Length
+            WriteLine($"Vous avez passé {args.Length} argument(s).");
+
+            WriteLine("Voici les arguments que vous avez passés :");
+
+            //foreach permet de parcourir les éléments de ce tableau d'arguments
+            foreach (string arg in args)
+            {
+                // \t permet d'insérer une tabulation
+                //ici, {0} sera remplacé par la valeur de arg
+                WriteLine($"\t{arg}");
+            }
+        }
+    }
+}

p02_Fondamentaux/ex_003_003_Main_arguments/Properties/launchSettings.json

@@ -0,0 +1,8 @@
+{
+  "profiles": {
+    "ex_003_003_Main_arguments": {
+      "commandName": "Project",
+      "commandLineArgs": "I love C# and .NET Core"
+    }
+  }
+}

p02_Fondamentaux/ex_003_003_Main_arguments/ReadMe.md

@@ -0,0 +1,19 @@
+## How to change the arguments passed to the Main method?
+
+##### Method 1:
+- Access the properties of the project (right click on the Project file -> Properties).
+- Access the debug tab
+- You can now change the application arguments!
+##### Method 2:
+- Change the launchSettings.json file in Properties  under the project file
+- to (for instance):
+``` json
+{
+  "profiles": {
+    "ex_003_003_Main_arguments": {
+      "commandName": "Project",
+      "commandLineArgs": "I love C# and .NET Core"
+    }
+  }
+}
+```

p02_Fondamentaux/ex_003_003_Main_arguments/ex_003_003_Main_arguments.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_003_003_Main_arguments</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_003_003_Main_arguments</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_003_004_Console/Program.cs

@@ -0,0 +1,103 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-21
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+using static System.Text.Encoding;
+
+namespace ex_003_004_Console
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = UTF8;
+
+            WriteLine("Voici un exemple d'utilisation de la console");
+
+            //utilisation de Write, qui écrit dans la Console, mais ne va pas à la ligne
+            Write("Avec Write, je ne vais pas à la ligne, ");
+
+            //WriteLine, écrit dans la Console, puis va à la ligne
+            WriteLine("mais avec Write Line, si.");
+
+            //toutes les variables peuvent être transformées en chaîne de caractères,
+            //car chaque type possède une méthode ToString() qui le transforme en chaîne de caractères.
+            //Dans le cas des types que vous créerez vous-même, vous devrez écrire cette méthode ToString,
+            //car la méthode par défaut ne vous conviendra pas souvent.
+            //Dans le cas des types .NET, vous pouvez l'utiliser directement, car elle toujours réécrite.
+            //Lorsque vous voulez afficher une variable dans la Console à l'aide de Write ou WriteLine,
+            //vous pouvez appeler explicitement ce ToString, ou ne rien faire, dans ce cas, ToString est appelée
+            //de manière implicite.
+            WriteLine("Je peux aussi écrire le contenu de variables : ");
+            int a = 2;
+            //les deux lignes suivantes font exactement la même chose (la première est juste plus simple)
+            WriteLine(a);
+            WriteLine(a.ToString());
+            int b = 3;
+            int c = a + b;
+            //dans la ligne suivante, le compilateur fait a.ToString() + " + " b.ToString() + " = " + c.ToString()
+            //car il commence par le premier + : a + " + "
+            //Lorsque le compilateur cherche à ajouter un entier à une chaîne de caractères, il transforme l'entier en chaîne de caractères
+            //puis concatène les deux.
+            //Il obtient donc la chaîne de caractères "2 + ", puis passe à la seconde opération : une chaîne de caractères + un entier
+            //Il transforme donc l'entier en chaîne de caractères et les concatène, etc...
+            WriteLine(a + " + " + b + " = " + c);
+            //Autre manière plus simple de l'écrire, et plus efficace, en utilisant un string.Format implicite
+            //(qui sera présenté plus tard)
+            WriteLine("{0} + {1} = {2}", a, b, c);
+            //ou encore depuis C#6 :
+            WriteLine($"{a} + {b} = {c}");
+
+            //à partir de ce que vous avez vu dans l'exemple précédent, essayez de déterminer le résultat des affichages suivants :
+            WriteLine("petit truc marrant :");
+            WriteLine(a + b + " = Somme");
+            WriteLine("Somme = " + a + b);
+            //le premier donne "5 = Somme" et le deuxième donne "Somme = 23"
+            //Dans le premier cas, le compilateur s'occupe du premier + : a + b 
+            //a et b sont deux entiers, il ajoute donc deux entiers : 2 + 3 = 5
+            //puis il ajoute un entier (5) et une chaîne de caractères " = Somme"
+            //Il transforme donc l'entier en chaîne de caractères puis les concatène : "5 = Somme"
+            //Dans le deuxième cas, il ajoute d'abord une chaîne de caractères "Somme = " et un entier a
+            //Il transforme donc l'entier en chaîne de caractères et les concatène, soit "Somme = " + "2" = "Somme = 2"
+            //Il ajoute ensuite une chaîne de caractères "Somme = 2" et un entier b
+            //Il transforme donc l'entier en chaîne de caractères "3" et les concatène : "Somme = 2" + "3" = "Somme = 23"
+
+            WriteLine("Ecrivez du texte puis appuyez sur Entrée");
+            //pour lire le texte entré par l'utilisateur
+            string s = ReadLine(); //lit jusqu'à l'appui sur ENTREE
+            WriteLine($"Vous avez écrit : {s}");
+            //attend l'appui sur une touche
+            ReadKey(true);
+
+
+
+            //on peut changer la couleur de fond
+            BackgroundColor = ConsoleColor.DarkBlue;
+
+            //on peut changer la couleur du texte
+            ForegroundColor = ConsoleColor.Yellow;
+            WriteLine("sympa mais vite illisible :)");
+
+            //on peut faire des beep
+            Beep();
+
+
+            //on peut obtenir des informations sur la Console, comme sa taille par exemple
+            WriteLine($"La fenêtre Console mesure {WindowHeight} caractères de haut et {WindowWidth} caractères de large");
+
+            //On peut effacfer le contenu de la Console avec Clear
+            WriteLine("Appuyez sur une touche pour effacer le contenu de la Console");
+            ReadKey(true);
+            Clear();
+        }
+    }
+}

p02_Fondamentaux/ex_003_004_Console/ex_003_004_Console.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_003_004_Console</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_003_004_Console</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_004_001_TypesNumeriques/Program.cs

@@ -0,0 +1,79 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-22
+// Mise à jour   : 2017-10-03
+//
+// ========================================================================
+
+using static System.Console;
+using static System.Text.Encoding;
+
+namespace ex_004_001_TypesNumeriques
+{
+    class Program
+    {
+        /// <summary>
+        /// Dans cet exemple, plusieurs variables de différents types sont présentées. Notez qu'un constante
+        /// de type float nécessite un f pour être différenciée d'un double
+        /// </summary>
+        /// <param name="args"></param>
+        static void Main(string[] args)
+        {
+            OutputEncoding = UTF8;
+
+            //types entiers
+            byte b; //variable codée sur un octet (n'importe quelle valeur entre 0 et 255)
+            sbyte sb; //variable codée sur un octet mais signée (n'importe quelle valeur entre -128 et 127)
+            short sh; //entier signé sur 16 bits. de -32768 à 32767 (automatiquement converti en int pendant une opération arithmétique)
+            ushort ush; //idem short, mais non signé : de 0 à 65535
+            int i; //entier codé sur 32 bits.
+            i = 10;
+            uint ui; //entier non signé codé sur 32 bits.
+            long l; //entier signé codé sur 64 bits.
+            l = 10L;
+            ulong ul; //entier non signé codé sur 64 bits.
+
+            //types réels
+            float f; //codé sur 32 bits
+            f = 4.5f;
+            double d; //codé sur 64 bits
+            d = 4.5;
+            decimal dec; //codé sur 128 bits, spécialement créé pour les applications financières. Plus précis mais 10 fois plus lent.
+            dec = 1.2m;
+
+            //le qualificatif const permet de garantir qu'une "variable" ne sera pas modifiée
+            const int ci = 3;
+
+            //membres des types numériques
+            WriteLine($"int.MinValue = {int.MinValue}");
+            WriteLine($"int.MaxValue = {int.MaxValue}");
+            WriteLine($"float.MinValue = {float.MinValue}");
+            WriteLine($"float.MaxValue = {float.MaxValue}");
+            WriteLine($"float.Epsilon = {float.Epsilon}");
+            WriteLine($"float.NegativeInfinity = {float.NegativeInfinity}");
+            WriteLine($"float.PositiveInfinity = {float.PositiveInfinity}");
+
+            //valeurs par défaut :
+            //numerique : 0
+
+
+            //Depuis C# 7.0, il y a eu quelques améliorations dans l'écriture des constantes numériques :
+            // - on peut maintenant utiliser l'underscore _ pour améliorer la lisibilité des grands nombres :
+            d = 123_456_789;
+            WriteLine(d);
+
+            // - on peut également l'utiliser sur les valeurs en hexadécimal :
+            d = 0x7_5B_CD_15;
+            WriteLine(d);
+
+            // - et également sur les nombres en binaire, ce qui peut éviter d'avoir à apprendre le nombre en hexadécimal :)
+            d = 0b111_0101_1011_1100_1101_0001_0101;
+            WriteLine(d);
+        }
+    }
+}

p02_Fondamentaux/ex_004_001_TypesNumeriques/ex_004_001_TypesNumeriques.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_004_001_TypesNumeriques</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_004_001_TypesNumeriques</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_004_002_Math/Program.cs

@@ -0,0 +1,99 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-22
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_004_002_Math
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            //constantes de la classe Math :
+            WriteLine($"CONSTANTES DE LA CLASSE MATH");
+            //epsilon
+            WriteLine($"E(e) : {Math.E}");
+            //PI
+            WriteLine($"Pi : {Math.PI}");
+
+            WriteLine();
+
+            //méthodes pour arrondir
+            WriteLine($"METHODES POUR ARRONDIR");
+            //arrondir 
+            WriteLine($"Arrondir 1,9876 à 2 chiffres après la virgule : {Math.Round(1.9876, 2)}");
+            //tronquer
+            WriteLine($"Partie entière de 1,9876 : {Math.Truncate(1.9876)}");
+            //plus grand entier inférieur
+            WriteLine($"Plus grand entier inférieur de 1,9876 : {Math.Floor(1.9876)}");
+            //plus petit entier supérieur
+            WriteLine($"Plus petit entier supérieur de 1,9876 : {Math.Ceiling(1.9876)}");
+
+            WriteLine();
+
+            //calcul de maximums et minimums
+            WriteLine($"maximum entre 6 et 4 : {Math.Max(6, 4)}");
+            WriteLine($"minimum entre 6 et 4 : {Math.Min(6, 4)}");
+            WriteLine($"maximum entre 6, 4 et 5 : {Math.Max(Math.Max(6, 4), 5)}"); //on peut faire mieux avec LINQ et les collections
+
+            WriteLine();
+
+            //signes et valeurs absolues
+            WriteLine($"valeur absolue de -4,567 : {Math.Abs(-4.567)}");
+            WriteLine($"signe de -4.567 : {Math.Sign(-4.567)}");
+
+            WriteLine();
+
+            //racines carrées, puissances, exponentielles et logarithmes
+            WriteLine($"Racine carrée de 625 : {Math.Sqrt(625)}");
+            WriteLine($"8 à la puissance 3 : {Math.Pow(8, 3)}");
+            WriteLine($"exponentielle de 1 (Exp(1)) : {Math.Exp(1)}");
+            WriteLine($"logarithme népérien de e (ln(e)) : {Math.Log(Math.E)}");
+            WriteLine($"logarithme décimal de 10 (log(10)) : {Math.Log10(10)}");
+
+            WriteLine();
+
+            //trigonométrie
+            WriteLine($"sin(pi/2) : {Math.Sin(Math.PI / 2)}");
+            WriteLine($"cos(pi/2) : {Math.Cos(Math.PI / 2)}");
+            WriteLine($"tan(pi/2) : {Math.Tan(Math.PI / 2)}");
+            //il existe aussi : le sinus hyperbolique (Sinh), le cosinus hyperbolique (Cosh), la tangente hyperbolique (Tanh)
+            //                  arcsinus (Asin), arccosinus (Acos) et arctan (Atan)
+
+            WriteLine();
+
+            //autres exemples :
+            WriteLine($"exp(e) = {Math.Exp(Math.E)}");
+            WriteLine($"ln(exp(1)) = {Math.Log(Math.Exp(1))}");
+            WriteLine($"sqrt(|cos(1)|) = {Math.Sqrt(Math.Abs(Math.Cos(1)))}");
+
+            WriteLine();
+
+            //L'assemblage System.Numerics.dll introduit également deux nouvelles classes :
+            // BigInteger : un très grand entier sans perte de précision
+            // Complex : une structure représentant un nombre complexe
+            System.Numerics.BigInteger carlos = System.Numerics.BigInteger.Pow(2, 200);
+            WriteLine($"2 à la puissance 200 :\n{carlos}");
+
+            System.Numerics.Complex complex = new System.Numerics.Complex(2, 3);
+            System.Numerics.Complex complex2 = new System.Numerics.Complex(-5, 2);
+            WriteLine($"Partie réelle de complex : {complex.Real} / partie imaginaire de complex : {complex.Imaginary}");
+            //les opérateurs sont réécrits pour les nombres complexes
+            System.Numerics.Complex complex3 = complex + complex2;
+            WriteLine($"(2 + 3i) + (-5 + 2i) = ({complex3.Real} + {complex3.Imaginary}i)");
+            complex3 = System.Numerics.Complex.Conjugate(complex);
+            WriteLine($"conjugué de (2 + 3i) = ({complex3.Real} + {complex3.Imaginary}i)");
+        }
+    }
+}

p02_Fondamentaux/ex_004_002_Math/ex_004_002_Math.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_004_002_Math</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_004_002_Math</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_004_003_Random/Program.cs

@@ -0,0 +1,47 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-22
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_004_003_Random
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            //juste pour que la fenêtre soit plus large et que le texte soit en conséquence plus lisible
+            WindowWidth += 5;
+
+            //Random crée une suite de nombre aléatoires en fonction d'une graine (seed)
+            Random rdm1 = new Random(); //utilise l'heure actuelle pour créer le seed automatiquement
+            //si vous relancez plusieurs fois le programme, le nombre va changer car l'heure varie.
+            WriteLine($"rdm1 : {rdm1.Next(20)} {rdm1.Next(20)} {rdm1.Next(20)} {rdm1.Next(20)} {rdm1.Next(20)}");
+
+            WriteLine();
+
+            //utilise le seed donné en paramètre
+            //la suite de nombres est donc toujours la même
+            //si vous relancez plusieurs fois le programme, vous aurez toujours la même suite de nombres.
+            //ce peut être utile pour recréer les mêmes conditions lors d'un debug
+            Random rdm2 = new Random(102394753);
+            WriteLine($"rdm2 : {rdm2.Next(20)} {rdm2.Next(20)} {rdm2.Next(20)} {rdm2.Next(20)} {rdm2.Next(20)}");
+
+            //différentes façons d'utiliser la classe Random
+            WriteLine($"rdm1.Next() retourne un nombre entier aléatoire non négatif :\n{rdm1.Next()}\n");
+            WriteLine($"rdm1.Next(20) retourne un nombre entier aléatoire dans l'intervalle [0;20[ :\n{rdm1.Next(20)}\n");
+            WriteLine($"rdm1.Next(5,20) retourne un nombre entier aléatoire dans l'intervalle [5;20[ :\n{rdm1.Next(5, 20)}\n");
+            WriteLine($"rdm1.NextDouble() retourne un nombre réel aléatoire dans l'intervalle [0.0;1.0[ :\n{rdm1.NextDouble()}\n");
+        }
+    }
+}

p02_Fondamentaux/ex_004_003_Random/ex_004_003_Random.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_004_003_Random</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_004_003_Random</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_004_004_TypeBool/Program.cs

@@ -0,0 +1,31 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-22
+//
+// ========================================================================
+
+using static System.Console;
+
+namespace ex_004_004_TypeBool
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            //type booléen
+            bool boolean; //true ou false
+
+            boolean = true;
+            WriteLine($"true : {true}");
+            WriteLine($"false : {false}");
+
+            WriteLine($"FalseString : {bool.FalseString}");
+            WriteLine($"TrueString : {bool.TrueString}");
+        }
+    }
+}

p02_Fondamentaux/ex_004_004_TypeBool/ex_004_004_TypeBool.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_004_004_TypeBool</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_004_004_TypeBool</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_004_005_TypeChar/Program.cs

@@ -0,0 +1,76 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-22
+//
+// ========================================================================
+
+using static System.Console;
+
+namespace ex_004_005_TypeChar
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            //type char
+            char c; //codé sur 16 bits ( != du C++ ), caractère du système Unicode
+            c = 'A';
+            c = '\x41'; //0x41 (ou 65 en décimal) dans Unicode. lettre A
+            c = (char)65; //idem
+            c = '\u0041'; //idem
+            //quelques caractères utiles
+            c = '\n'; //à la ligne
+            c = '\t'; //tabulation horizontale
+            c = '\v'; //tabulation verticale
+            c = '\\'; //backslash
+            c = '\''; //single quote
+            c = '\"'; //double quote
+            c = '\0'; //null
+
+            //quelques membres du type char :
+            char a = 'A';
+            char deux = '2';
+            char virgule = ',';
+            char blanc = ' ';
+            //IsDigit : le caractère est-il un chiffre ?
+            WriteLine($"char.IsDigit('A') ? {char.IsDigit(a)}");
+            WriteLine($"char.IsDigit('2') ? {char.IsDigit(deux)}");
+            WriteLine($"char.IsDigit(',') ? {char.IsDigit(virgule)}");
+            WriteLine($"char.IsDigit(' ') ? {char.IsDigit(blanc)}");
+            WriteLine();
+            //IsLetter indique s'il s'agit d'une lettre
+            WriteLine($"char.IsLetter('A') ? {char.IsLetter(a)}");
+            WriteLine($"char.IsLetter('2') ? {char.IsLetter(deux)}");
+            WriteLine($"char.IsLetter(',') ? {char.IsLetter(virgule)}");
+            WriteLine($"char.IsLetter(' ') ? {char.IsLetter(blanc)}");
+            //il y a aussi IsLower pour les minuscules,  IsUpper pour les majuscules, IsLetterOrDigit pour lettres ou nombres
+            WriteLine();
+
+            //IsPunctuation indique s'il s'agit d'un caractère de ponctuation
+            WriteLine($"char.IsPunctuation('A') ? {char.IsPunctuation(a)}");
+            WriteLine($"char.IsPunctuation('2') ? {char.IsPunctuation(deux)}");
+            WriteLine($"char.IsPunctuation(',') ? {char.IsPunctuation(virgule)}");
+            WriteLine($"char.IsPunctuation(' ') ? {char.IsPunctuation(blanc)}");
+            WriteLine();
+
+            //IsWhiteSpace indique s'il s'agit d'un blanc
+            WriteLine($"char.IsWhiteSpace('A') ? {char.IsWhiteSpace(a)}");
+            WriteLine($"char.IsWhiteSpace('2') ? {char.IsWhiteSpace(deux)}");
+            WriteLine($"char.IsWhiteSpace(',') ? {char.IsWhiteSpace(virgule)}");
+            WriteLine($"char.IsWhiteSpace(' ') ? {char.IsWhiteSpace(blanc)}");
+            WriteLine();
+
+            //ToUpper et ToLower convertisse en majuscules ou en minuscules.
+            WriteLine($"char.ToLower('A') = {char.ToLower('A')}");
+            WriteLine($"char.ToUpper('a') = {char.ToUpper('a')}");
+            WriteLine($"char.ToUpper('é') = {char.ToUpper('é')}");
+        }
+    }
+}

p02_Fondamentaux/ex_004_005_TypeChar/ex_004_005_TypeChar.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_004_005_TypeChar</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_004_005_TypeChar</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_004_006_TimeSpan_et_DateTime/Program.cs

@@ -0,0 +1,72 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-22
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_004_006_TimeSpan_et_DateTime
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            //TimeSpan
+            //construction d'une durée à partir d'un constructeur
+            TimeSpan durée_d_un_cours = new TimeSpan(1, 50, 00);
+            //construction d'une durée à partir d'un nombre de minutes (ou heures, ou secondes...)
+            TimeSpan retard = TimeSpan.FromMinutes(21.20);
+            //opération (addition, soustraction) de durées
+            TimeSpan durée_du_cours_aujourd_hui = durée_d_un_cours + retard;
+            //durée nulle
+            TimeSpan durée_nulle = TimeSpan.Zero;
+            //affichage d'une durée
+            WriteLine($"Le cours d'aujourd'hui est de {durée_d_un_cours} + {retard} de retard = {durée_du_cours_aujourd_hui}");
+            WriteLine();
+
+            //DateTime
+            //construction d'un DateTime
+            DateTime débutDeJazzEnTete2012 = new DateTime(2012, 10, 23, 20, 00, 00);
+            DateTime finDeJazzEnTete2012 = new DateTime(2012, 10, 27, 23, 59, 00);
+            //soustraction de DateTime
+            TimeSpan duréeDeJazzEnTete2012 = finDeJazzEnTete2012.Subtract(débutDeJazzEnTete2012);
+            //affichage de DateTime
+            WriteLine($"Le festival jazz en tête a duré : {duréeDeJazzEnTete2012}");
+            WriteLine($"Le festival jazz en tête a duré : {duréeDeJazzEnTete2012.Days} jours et {duréeDeJazzEnTete2012.Hours} heures");
+            WriteLine($"Le festival jazz en tête a duré : {duréeDeJazzEnTete2012.Days} jours et {Math.Round(duréeDeJazzEnTete2012.TotalHours - (duréeDeJazzEnTete2012.Days * 24))} heures");
+            //on peut ajouter ou soustraire du temps à 1 DateTime
+            DateTime débutDernierConcert = finDeJazzEnTete2012 - TimeSpan.FromHours(4);
+            //autre solution équivalente
+            débutDernierConcert = finDeJazzEnTete2012.Subtract(TimeSpan.FromHours(4));
+            WriteLine($"Le dernier concert de Jazz en Tete commence le : {débutDernierConcert.ToString("dd/MM/yyy")} à {débutDernierConcert.ToString("hh:mm")}");
+
+            WriteLine();
+
+            //gestion des décalages horaires
+            DateTime début_de_la_finale_de_l_USOpen = new DateTime(2010, 09, 13, 20, 00, 00, DateTimeKind.Utc);
+            WriteLine($"La finale commencera : {début_de_la_finale_de_l_USOpen.ToLocalTime().ToString("f")} chez nous");
+            WriteLine($"La finale commencera : {(début_de_la_finale_de_l_USOpen - TimeSpan.FromHours(4)).ToString("g")} à New York");
+            WriteLine();
+
+            //on peut parser une chaîne de caractères !
+            string date_réjouissances = "jeudi 29 septembre 2011 13:30";
+            WriteLine("Convertir jeudi 29 septembre 2011 13:30 en DateTime ? oui bien sûr !");
+            DateTime réjouissances = DateTime.Parse(date_réjouissances);
+            WriteLine(réjouissances);
+
+            //la date et l'heure actuelles (au moment de l'exécution de la ligne)
+            //est donnée par :
+            DateTime maintenant = DateTime.Now;
+            WriteLine($"Maintenant : {maintenant}");
+        }
+    }
+}

p02_Fondamentaux/ex_004_006_TimeSpan_et_DateTime/ex_004_006_TimeSpan_et_DateTime.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_004_006_TimeSpan_et_DateTime</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_004_006_TimeSpan_et_DateTime</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_004_007_DureeDeVie/Program.cs

@@ -0,0 +1,41 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-22
+//
+// ========================================================================
+
+using System;
+
+
+namespace ex_004_007_DureeDeVie
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            int a = 2;//la pile contient ... a
+
+            int b = 3;//la pile contient ... a b
+
+            float f = 10;//la pile contient ... a b f
+
+            {
+                int c = a + b; //la pile contient ... a b f c
+                f /= c; //f est modifié, la pile contient ... a b f c
+            }//c meurt ici, la pile contient ... a b f
+
+            TimeSpan ts = TimeSpan.FromHours(2); //la pile contient ... a b f ts
+
+            {
+                TimeSpan ts2 = ts - TimeSpan.FromHours(1); //la pile contient ... a b f ts ts2
+            }//ts2 meurt ici, la pile contient ... a b f ts 
+
+
+        }//a, b, f, ts meurent ici, la pile contient ...
+    }
+}

p02_Fondamentaux/ex_004_007_DureeDeVie/ex_004_007_DureeDeVie.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_004_007_DureeDeVie</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_004_007_DureeDeVie</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_004_008_var/Program.cs

@@ -0,0 +1,29 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-22
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_004_008_var
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            //var : mot clé pour déclarer en même temps qu'on initialise une variable
+            //le type est automatiquement choisi
+            var var1 = 5; // est équivalent à int var1 = 5;
+            WriteLine($"le type de var1 est {var1.GetType()}");
+            var var2 = "coucou"; // est équivalent à string var2 = "coucou";
+            WriteLine($"le type de var2 est {var2.GetType()}");
+        }
+    }
+}

p02_Fondamentaux/ex_004_008_var/ex_004_008_var.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_004_008_var</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_004_008_var</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_004_009_Tuple/Program.CSharp7.cs

@@ -0,0 +1,92 @@
+// ========================================================================
+//
+// Copyright (C) 2017-2018 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.CSharp7.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2017-09-19
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_004_009_Tuple
+{
+    partial class Program
+    {
+        /// <summary>
+        /// Le constat sur l'utilisation des Tuples jusqu'à C# 6.0 est le suivant :
+        ///     - l'utilisation des paramètres out (a priori rien à voir avec les Tuples), n'est pas pratique et lourd et ils ne marchent pas avec les méthodes asynchrones
+        ///     - l'utilisation des Tuples est verbeuse et l'allocation est lourde
+        ///     - ceci entraine beaucoup d'écriture de code pour des variables à durée de vie parfois très limitée
+        ///     
+        /// C# 7.0 ajoute donc les types Tuple et des sucres syntaxiques pour améliorer tout ceci ... :
+        /// </summary>
+        static void NouveautésCSharp7()
+        {
+            //La méthode suivante rend directement trois variables en un "tuple value" : un string, et deux int
+            //ATTENTION : ceci n'est utilisable que si vous ajoutez le package NuGet System.TupleValue
+            (string, int, int) NounoursData(Nounours nounours)
+            {
+                return (nounours.Nom, nounours.NbPoils, nounours.Naissance.Year);
+            }
+            //pour utiliser le résultat de la méthode ci-dessous, vous pouvez tout stocker dans une seule variable var (de type Tuple<string, int, int> ici) :
+            var test = NounoursData(new Nounours { Nom = "Gizmo", NbPoils = 123456789, Naissance = new DateTime(1984, 6, 8) });
+            //et accéder aux différentes valeurs avec Item1, Item2, Item3...
+            WriteLine($"{test.Item1} ; {test.Item2} ; {test.Item3}");
+
+            //un des problèmes des Tuples, c'est que Item1, Item2, Item3... ce n'est pas très parlant. On peut donc réécrire la méthode
+            //de la manière suivante, en donnant un nom aux valeurs de retour :
+            (string nom, int nbPoils, int annéeDeNaissance) NounoursData2(Nounours nounours)
+            {
+                return (nounours.Nom, nounours.NbPoils, nounours.Naissance.Year);
+                //cette dernière ligne peut aussi s'écrire :
+                //return (nom: nounours.Nom, nbPoils: nounours.NbPoils, annéeDeNaissance: nounours.Naissance.Year);
+                //au cas où vous ne calculeriez pas les éléments dans le bon ordre
+            }
+            //l'accès aux résultats reste inchangé :
+            var test2 = NounoursData2(new Nounours { Nom = "Gizmo", NbPoils = 123456789, Naissance = new DateTime(1984, 6, 8) });
+            //par contre, on n'utilise plus Item1, Item2, Item3, mais les noms utilisés en retour de la méthode (ici nom, nbPoils et annéeDeNaissance)
+            WriteLine($"{test2.nom} ; {test2.nbPoils} ; {test2.annéeDeNaissance}");
+
+            //notez que les noms n'ont pas d'autre intérêt que de simplifier l'utilisation. C'est le type des éléments des Tuples qui permet de comparer deux Tuples.
+
+
+            //DECONSTRUCTION
+            //La deconstruction est une syntaxe pour diviser un tuple (ou un autre type) en ses différents éléments en de nouvelles variables individuelles
+            //ci-dessous, au lieu de stocker le retour de la méthode NounoursData précédente dans un Tuple, on le stocker dans une Tuple "déconstruit"
+            (string nom, int nbPoils, int année) = NounoursData(new Nounours { Nom = "Gizmo", NbPoils = 123456789, Naissance = new DateTime(1984, 6, 8) });
+            WriteLine($"{nom} ; {nbPoils} ; {année}");
+
+            //on peut aussi utiliser var comme d'habitude
+            (var nom2, var nbPoils2, var année2) = NounoursData(new Nounours { Nom = "Gizmo", NbPoils = 123456789, Naissance = new DateTime(1984, 6, 8) });
+            WriteLine($"{nom2} ; {nbPoils2} ; {année2}");
+
+            //ou bien utiliser var devant le tuple literal
+            var (nom3, nbPoils3, année3) = NounoursData(new Nounours { Nom = "Gizmo", NbPoils = 123456789, Naissance = new DateTime(1984, 6, 8) });
+            WriteLine($"{nom3} ; {nbPoils3} ; {année3}");
+
+            //ou encore déconstruire dans des variables existantes :
+            string nom4;
+            int nbPoils4, année4;
+            (nom4, nbPoils4, année4) = NounoursData(new Nounours { Nom = "Gizmo", NbPoils = 123456789, Naissance = new DateTime(1984, 6, 8) });
+            WriteLine($"{nom4} ; {nbPoils4} ; {année4}");
+
+            //Notez qu'on peut déconstruire autre chose que des Tuples (cf. ex_
+        }
+    }
+
+    class Nounours
+    {
+        public string Nom { get; set; }
+        public int NbPoils { get; set; }
+        public DateTime Naissance { get; set; }
+
+        public override string ToString()
+        {
+            return $"{Nom} a {NbPoils} poils et est né en {Naissance.Year}";
+        }
+    }
+}

p02_Fondamentaux/ex_004_009_Tuple/Program.cs

@@ -0,0 +1,61 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-10-01
+// Updated       : 2017-09-19
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_004_009_Tuple
+{
+    partial class Program
+    {
+        /// <summary>
+        /// la classe Tuple est générique (voir chapitre 22) et permet de stocker plusieurs références ou valeurs de différents types.
+        /// Tuple est notamment très pratique pour avoir plusieurs retours de méthodes.
+        /// Tuple possède des propriétés (voir chapitre 16) en lecture seule permettant d'accéder aux différents éléments du Tuple.
+        /// Par exemple, si on déclare Tuple<string, int, float>, alors Item1 permet d'accéder au string, Item2 à l'int, Item3 au float.
+        /// 
+        /// Les Tuples sont des types "valeur" et leurs éléments sont publics et mutables. Ils implémentent le protocole d'égalité des types "valeur",
+        /// i.e. 2 Tuples sont égaux (et ont le même hash code) si et seulement si leurs éléments sont égaux deux à deux (et ont le même hashcode).
+        /// Ceci rend les Tuples très utiles dans de nombreuses situations. Par exemple : 
+        ///     - un dictionnaire avec plusieurs clés : utilisez un tuple comme clef
+        ///     - une liste avec plusieurs valeurs à chaque indice : utilisez un tuple
+        ///     
+        /// Depuis, C#7.0, il y a eu de nombreux ajouts aux Tuples (voir le 2ème fichier : Program.CSharp7.cs)
+        /// </summary>
+        /// <param name="args"></param>
+        static void Main(string[] args)
+        {
+            //création d'un Tuple
+            Tuple<string, int, float> tuple = new Tuple<string, int, float>("ObiWan Kenobi", 4, 3.2f);
+            Tuple<string, int, float> tuple2 = Tuple.Create("ObiWan Kenobi", 4, 3.2f);
+
+            WriteLine($"{tuple.Item1} {tuple.Item2} {tuple.Item3}");
+
+            WriteLine();
+            int a = 3;
+            var result = DoubleEtTriple(a);
+            WriteLine($"le double et le triple de {a} sont {result.Item1} et {result.Item2}");
+
+            NouveautésCSharp7();
+        }
+
+        /// <summary>
+        /// une méthode qui rend le double et le triple d'un nombre
+        /// </summary>
+        /// <param name="a">nombre à doubler et tripler</param>
+        /// <returns>le double et le triple du nombre</returns>
+        static Tuple<int, int> DoubleEtTriple(int a)
+        {
+            return Tuple.Create(a * 2, a * 3);
+        }
+    }
+}

p02_Fondamentaux/ex_004_009_Tuple/ex_004_009_Tuple.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_004_009_Tuple</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_004_009_Tuple</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="System.ValueTuple" Version="4.5.0" />
+  </ItemGroup>
+</Project>

p02_Fondamentaux/ex_004_010_GuidStruct/Program.cs

@@ -0,0 +1,37 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-10-01
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_004_010_GuidStruct
+{
+    class Program
+    {
+        /// <summary>
+        /// la structure (voir chapitre 20) Guid permet de définir des indentifiants presque uniques.
+        /// Lorsque vous générez un de ces identifiants, il est très fort probable qu'il soit unique au monde.
+        /// Il y a 2 puissance 128 Guid différents.
+        /// </summary>
+        /// <param name="args"></param>
+        static void Main(string[] args)
+        {
+            Guid g = Guid.NewGuid();
+            WriteLine(g);
+
+            Guid g2 = new Guid("{9128de4d-1423-4e08-8ca6-a9effbba1f86}");
+            Guid g3 = new Guid("9128de4d14234e088ca6a9effbba1f86");
+            WriteLine(g2 == g3);
+
+            WriteLine(Guid.Empty);
+        }
+    }
+}

p02_Fondamentaux/ex_004_010_GuidStruct/ex_004_010_GuidStruct.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_004_010_GuidStruct</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_004_010_GuidStruct</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_005_001_tableaux/Program.cs

@@ -0,0 +1,115 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-22
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_005_001_tableaux
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            WindowHeight = LargestWindowHeight;
+
+            //DECLARATION ET ALLOCATION DYNAMIQUE DE LA MEMOIRE
+            int[] tab; //tab est une référence. Ici, on sait juste que tab désignera un tableau d'entiers à 1 dimension. Ce n'est pas ici 
+            //qu'on indique la taille. tab étant une référence, il est alloué sur la pile.
+
+            tab = new int[3]; //maintenant on alloue la place en mémoire (ici pour 3 entiers) sur le tas.
+            // Il s'agit donc d'une allocation dynamique
+
+            // en une seule fois : 
+            int[] tab2 = new int[3];
+
+
+            //ALLOCATION DYNAMIQUE ET INITIALISATION EN MEME TEMPS 
+            int[] tab3;
+            tab3 = new int[] { 1, 2, 3, 4, 5 }; //on peut aussi spécifier directement les valeurs du tableau. Pas la peine donc de donner
+                                                //la taille du tableau dans ce cas.
+
+            //en une seule fois : 
+            int[] tab4 = { 1, 2, 3, 4, 5 };
+
+            //INITIALISATION AUTOMATIQUE
+            int[] tab4b = new int[5];
+            WriteLine(tab4b[2]); // les types numériques sont initialisés à 0 automatiquement
+            bool[] tab4c = new bool[100];
+            WriteLine(tab4c[53]); // les types bool sont initialisés automatiquement à false
+            //tous les types références (classes et string par exemple sont initialisés à null)
+
+
+            //LIBERATION DE LA MEMOIRE
+            //la libération est automatique, on n'appelle pas delete.
+
+            //ACCES AUX ELEMENTS DU TABLEAU
+            //les accès aux cellules du tableau se font comme en C/C++
+            int a = tab4[0]; //a vaut 1
+            a = tab4[1];//a vaut 2
+            a = tab4[2];//a vaut 3
+            a = tab4[3];//a vaut 4
+            a = tab4[4];//a vaut 5
+
+            //CONTROLE DES ACCES EN DEHORS DU TABLEAU
+            //les accès en dehors du tableau sont contrôlées par le runtime
+            // et provoque des exceptions IndexOutOfRangeException
+            try
+            {
+                WriteLine(tab4[5]);
+            }
+            catch (IndexOutOfRangeException)
+            {
+                WriteLine("tab4[5] a provoqué une exception");
+            }
+
+            //TAILLE DU TABLEAU
+            //la taille d'un tableau est donnée par la propriété Length
+            WriteLine($"taille du tableau tab4 : {tab4.Length}");
+
+            //PARCOURIR LES ELEMENTS D'UN TABLEAU
+            //avec une boucle for
+            WriteLine("tab4 : ");
+            for (int i = 0; i < tab4.Length; i++)
+            {
+                WriteLine(tab4[i]);
+            }
+            //avec une boucle foreach
+            foreach (var elt in tab4)
+            {
+                WriteLine(elt);
+            }
+
+            //TABLEAU D'OBJECT
+            //tableaux avec des cellules de types différents
+            object[] tab5 = new object[3];
+            tab5[0] = 12;       //contient un entier
+            tab5[1] = 3.4f;     //contient un réel
+            tab5[2] = "arf";    //contient une chaîne de caractères
+            //pour déterminer ensuite le type :
+            for (int i = 0; i < tab5.Length; i++)
+            {
+                Type type = tab5[i].GetType();
+                string s = type.Name;
+                WriteLine(s);
+            }
+            //ou pour l'utiliser : 
+            for (int i = 0; i < tab5.Length; i++)
+            {
+                if (tab5[i] is int)
+                {
+                    WriteLine(tab5[i]);
+                }
+            }
+        }
+    }
+}

p02_Fondamentaux/ex_005_001_tableaux/ex_005_001_tableaux.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_005_001_tableaux</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_005_001_tableaux</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_005_002_copie_de_tableaux/Program.cs

@@ -0,0 +1,124 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-22
+//
+// ========================================================================
+
+using static System.Console;
+
+namespace ex_005_002_copie_de_tableaux
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            WindowHeight = LargestWindowHeight;
+
+
+            //COPIE DE TABLEAUX
+            WriteLine("\nCopie de tableaux");
+
+            //1. copie de références
+            WriteLine("\nCopie de références\n");
+            //préparation des tableaux
+            int[] tab6 = { 1, 2, 3 };
+            int[] tab7 = { 5, 6, 7, 8, 9, 10 };
+            WriteLine("contenu de tab6");
+            foreach (int i in tab6) Write($"{i} ");
+            WriteLine();
+            WriteLine("contenu de tab7");
+            foreach (int i in tab7) Write($"{i} ");
+            WriteLine();
+            //recopie des références
+            WriteLine("tab7 = tab6;");
+            tab7 = tab6; //attention, on ne copie que les références ! le contenu est donc partagé ! La preuve :
+            //affichage des tableaux après copie des références
+            WriteLine("contenu de tab6");
+            foreach (int i in tab6) Write($"{i} ");
+            WriteLine();
+            WriteLine("contenu de tab7");
+            foreach (int i in tab7) Write($"{i} ");
+            WriteLine();
+            //modification d'une case d'un des tableaux
+            WriteLine("tab7[1] = 4;");
+            tab7[1] = 4;
+            //affichage des contenus après copie modification d'un des deux tableaux
+            WriteLine("contenu de tab7");
+            foreach (int i in tab7) Write($"{i} ");
+            WriteLine();
+            WriteLine("contenu de tab6");
+            foreach (int i in tab6) Write($"{i} ");
+            WriteLine();
+
+            //2. copie de contenus, méthode 1 : new + CopyTo
+            WriteLine("\nCopie de contenus, méthode 1\n");
+            //préparation des tableaux
+            int[] tab8 = { 5, 6, 7, 8, 9, 10 };
+            WriteLine("contenu de tab6");
+            foreach (int i in tab6) Write($"{i} ");
+            WriteLine();
+            WriteLine("contenu de tab8");
+            foreach (int i in tab8) Write($"{i} ");
+            WriteLine();
+            //recopie des contenus
+            WriteLine("tab8 = new int[tab6.Length];\ntab6.CopyTo(tab8, 0);");
+            tab8 = new int[tab6.Length]; // on alloue la place de tab6 pour tab8
+            tab6.CopyTo(tab8, 0); // on recopie le contenu de tab6 dans tab8 (ils ont la même taille à cause de la ligne d'avant, donc tout va bien)
+            //affichage des résultats
+            WriteLine("contenu de tab6");
+            foreach (int i in tab6) Write($"{i} ");
+            WriteLine();
+            WriteLine("contenu de tab8");
+            foreach (int i in tab8) Write($"{i} ");
+            WriteLine();
+            //modification d'un des deux tableaux
+            WriteLine("tab8[1] = 2;");
+            tab8[1] = 2;
+            //affichage des contenus après modification d'un des deux tableaux
+            WriteLine("contenu de tab6");
+            foreach (int i in tab6) Write($"{i} ");
+            WriteLine();
+            WriteLine("contenu de tab8");
+            foreach (int i in tab8) Write($"{i} ");
+            WriteLine();
+
+            //3. copie de contenus, méthode 2 : Clone
+            WriteLine("\nCopie de contenus, méthode 2\n");
+            //préparation des tableaux
+            int[] tab9 = { 5, 6, 7, 8, 9, 10 };
+            WriteLine("contenu de tab6");
+            foreach (int i in tab6) Write($"{i} ");
+            WriteLine();
+            WriteLine("contenu de tab9");
+            foreach (int i in tab9) Write($"{i} ");
+            WriteLine();
+            //clonage des tableaux
+            WriteLine("tab9 = (int[])tab6.Clone();");
+            tab9 = (int[])tab6.Clone();
+            //affichage après clonage
+            WriteLine("contenu de tab6");
+            foreach (int i in tab6) Write($"{i} ");
+            WriteLine();
+            WriteLine("contenu de tab9");
+            foreach (int i in tab9) Write($"{i} ");
+            WriteLine();
+            //modification d'un des deux tableaux
+            WriteLine("tab9[1] = 2;");
+            tab9[1] = 2;
+            //affichage après modification
+            WriteLine("contenu de tab6");
+            foreach (int i in tab6) Write($"{i} ");
+            WriteLine();
+            WriteLine("contenu de tab9");
+            foreach (int i in tab9) Write($"{i} ");
+            WriteLine();
+        }
+    }
+}

p02_Fondamentaux/ex_005_002_copie_de_tableaux/ex_005_002_copie_de_tableaux.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_005_002_copie_de_tableaux</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_005_002_copie_de_tableaux</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_005_003_tableaux_multiDimensions/Program.cs

@@ -0,0 +1,70 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-22
+//
+// ========================================================================
+
+using static System.Console;
+
+namespace ex_005_003_tableaux_multiDimensions
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            //TABLEAUX A PLUSIEURS DIMENSIONS
+            int[,] mat = new int[2, 3]; //2 lignes et 3 colonnes
+            int[,] mat2 = { { 1, 2, 3 }, { 4, 5, 6 } };
+            int[,,] tab10;//3 dimensions
+            //pour copier, on peut utiliser la méthode Clone
+            //parcours d'un tableau à plusieurs dimensions
+            WriteLine("\nTABLEAUX A DEUX DIMENSIONS");
+            for (int ligne = 0; ligne < mat2.GetLength(0); ligne++)
+            {
+                for (int colonne = 0; colonne < mat2.GetLength(1); colonne++)
+                {
+                    Write($"{mat2[ligne, colonne]} ");
+                }
+                WriteLine();
+            }
+
+            //TABLEAUX EPARSES
+            int[][] jagged = new int[3][];//tableaux à trois lignes de tailles différentes
+            jagged[0] = new int[2];
+            jagged[0][0] = 10;
+            jagged[0][1] = 20;
+            jagged[1] = new int[4];
+            jagged[1][0] = 30;
+            jagged[1][1] = 40;
+            jagged[1][2] = 50;
+            jagged[1][3] = 60;
+            jagged[2] = new int[3];
+            jagged[2][0] = 70;
+            jagged[2][1] = 80;
+            jagged[2][2] = 90;
+            WriteLine("\nTABLEAUX EPARSES");
+            for (int ligne = 0; ligne < jagged.GetLength(0); ligne++)
+            {
+                for (int colonne = 0; colonne < jagged[ligne].Length; colonne++)
+                {
+                    Write($"{jagged[ligne][colonne]} ");
+                }
+                WriteLine();
+            }
+            //initialisation directe
+            int[][] jagged2 = new int[][]
+                              {
+                                  new int[] {10, 20},
+                                  new int[] {30, 40, 50, 60},
+                                  new int[] {70, 80, 90}
+                              };
+
+
+        }
+    }
+}

p02_Fondamentaux/ex_005_003_tableaux_multiDimensions/ex_005_003_tableaux_multiDimensions.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_005_003_tableaux_multiDimensions</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_005_003_tableaux_multiDimensions</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_006_001_string/Program.cs

@@ -0,0 +1,182 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-22
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_006_001_string
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            WindowHeight = LargestWindowHeight;
+            WindowWidth += 15;
+
+            WriteLine("STRING : Chaîne de caractères immuable");
+
+            //construction
+            WriteLine("CONSTRUCTION");
+            string s1 = "Bonjour";
+
+            //caractères spéciaux avec le caractère d'échappement \
+            WriteLine("CARACTERES SPECIAUX");
+            string s2 = "\'coucou1\' \"coucou2\" \\coucou3\\";
+            WriteLine(s2);
+            s2 = "nouvelle\nligne";
+            WriteLine(s2);
+            s2 = "retour\rcharriot";
+            WriteLine(s2);
+            s2 = "horizontal\ttab";
+            WriteLine(s2);
+            s2 = "alerte audio \a"; // \a fait un son lorsque le string est affiché
+            WriteLine(s2);
+
+            //verbatim
+            WriteLine("\n VERBATIM");
+            string s3 = "\\\\server\\machin\\trucmuche\\home"; // chaîne non verbatim, il faut utiliser le caractère d'échappement pour afficher 
+                                                               // les backslashs
+            WriteLine(s3);
+            s3 = @"\\server\machin\truchmuche\home";           // chaîne verbatim, les caractères spéciaux sont traités comme les autres
+            WriteLine(s3);
+
+            //string vide
+            WriteLine("\n CHAINE DE CARACTERES VIDE");
+            string s4 = "";
+            WriteLine($"la chaîne de caractères : \"{s4}\" a une longueur de : {s4.Length} caractère(s)");
+            //ou
+            s4 = String.Empty;
+            WriteLine($"la chaîne de caractères : \"{s4}\" a une longueur de : {s4.Length} caractère(s)");
+            WriteLine($"s4 == \"\" ? {s4 == ""}");
+            WriteLine($"s4 == String.Empty ? {s4 == string.Empty}");
+            WriteLine($"s4.Length == 0 ? {s4.Length == 0}");
+
+            //string null (string est reference type)
+            WriteLine("\n CHAINE DE CARACTERES NULLE");
+            string s5 = null;
+            WriteLine($"s5 == \"\" ? {s5 == ""}");
+            try
+            {
+                WriteLine($"s5.Length == 0 ? {s5.Length == 0}");
+            }
+            catch
+            {
+                WriteLine($"s5.Length == 0 ? False");
+            }
+
+            WriteLine($"string.IsNullOrEmpty(s4) ? {string.IsNullOrEmpty(s4)}");
+            WriteLine($"string.IsNullOrEmpty(s5) ? {string.IsNullOrEmpty(s5)}");
+            WriteLine($"string.IsNullOrWhiteSpace(\"   \") ? {string.IsNullOrWhiteSpace("   ")}");
+
+            //accéder et chercher dans les string
+            WriteLine($"\n RECHERCHER DANS LES STRING");
+            string s6 = "barbapapa";
+            WriteLine(s6);
+            WriteLine($"3ème caractère : {s6[2]}");
+            WriteLine($"s6.Contains(\"pa\") ? {s6.Contains("pa")}");
+            WriteLine($"s6.EndsWith(\"pa\") ? {s6.EndsWith("pa")}");
+            WriteLine($"s6.StartsWith(\"ba\") ? {s6.StartsWith("ba")}");
+            WriteLine($"s6.IndexOf(\"ba\") ? {s6.IndexOf("ba")}");
+
+            //manipuler les string
+            WriteLine($"\n MANIPULER LES STRING");
+            WriteLine($"CONCATENATION DE STRING");
+            //concatenation de string
+            string s7 = "Jim" + " " + "Raynor";
+            WriteLine($"\"Jim\" + \" \" + \"Raynor\" = \"{s7}\"");
+            //substring
+            WriteLine($"SUBSTRING");
+            string s8 = s7.Substring(0, 3);
+            WriteLine($"\"Jim Raynor\".Substring(0, 3) = {s8}");
+            s8 = s7.Substring(2, 3);
+            WriteLine($"\"Jim Raynor\".Substring(2, 3) = {s8}");
+            s8 = s7.Substring(5);
+            WriteLine($"\"Jim Raynor\".Substring(5) = {s8}");
+
+            //insert, remove, replace, ToUpper, ToLower
+            WriteLine($"REMOVE");
+            s8 = s7.Remove(2, 3);
+            WriteLine($"\"Jim Raynor\".Remove(2, 3) = {s8}");
+            WriteLine($"INSERT");
+            s8 = s8.Insert(2, "m R");
+            WriteLine($"\"Jiaynor\".Insert(2, \"m R\") = {s8}");
+            WriteLine($"REPLACE");
+            s8 = "Les chaussettes de l'archiduchesse";
+            s8 = s8.Replace(" ", "_");
+            WriteLine($"\"Les chaussettes de l'archiduchesse\".Replace(\" \", \"_\") = {s8}");
+            WriteLine($"TO UPPER, TO LOWER");
+            s8 = s8.ToUpper();
+            WriteLine($"\"Les_chaussettes_de_l'archiduchesse\".ToUpper() = {s8}");
+            s8 = s8.ToLower();
+            WriteLine($"\"LES_CHAUSSETTES_DE_L'ARCHIDUCHESSE\".ToLower() = {s8}");
+
+
+            //PadLeft, PadRight
+            WriteLine("\n PADLEFT, PADRIGHT, TRIM");
+            s8 = s8.PadLeft(50).PadRight(60, '!');
+            WriteLine($"\"les_chaussettes_de_l'archiduchesse\".PadLeft(50).PadRight(60, \'!\') = \n{s8}");
+
+
+            //Trim : enlève les blancs (whitespace, tab, new lines...)
+            s8 = s8.Trim(); //existe aussi avec TrimStart et TrimEnd
+            WriteLine($"\"                les_chaussettes_de_l'archiduchesse!!!!!!!!!!\".Trim() = \n{s8}");
+
+            //Split et Join
+            WriteLine("\n SPLIT ET JOIN");
+            s8 = "Les chaussettes de l'archiduchesse";
+            WriteLine($"\"{s8}\" est composé des mots suivants \n(\"Les chaussettes de l'archiduchesse\".Split()): ");
+            string[] mots = s8.Split();
+            foreach (string m in mots)
+            {
+                WriteLine($"\t- {m}");
+            }
+            WriteLine("On peut regrouper les mots précédents (tableau de string : string[] mots;) avec Join");
+            string s9 = string.Join(" ", mots);
+            WriteLine($"string.Join(\" \", mots) = {s9}");
+
+            //Format
+            WriteLine("\n STRING.FORMAT");
+            string format = "Il y a {0} élèves inscrits en {1} année à l'IUT pour l'année scolaire {2}";
+            WriteLine("Le format : \"{0}\"", format);
+            string chaineFormatée = string.Format(format, 110, "2ème", "2011-2012");
+            WriteLine("chaîne formatée avec le format : {0}", chaineFormatée);
+            WriteLine("on peut aussi tout faire dans le WriteLine, sans préciser string.Format : ");
+            WriteLine("Il y a {0} élèves inscrits en {1} année à l'IUT pour l'année scolaire {2}", 110, "2ème", "2010-2011");
+            format = "Nb élèves : {0, -5} Année : {1, -5} Année universitaire : {2, 15}";
+            WriteLine("format plus élaboré, pour imposer des tailles : \n{0}", format);
+            WriteLine("Quelques chaînes formatées (avec ou sans string.Format pour voir la différence d'écriture) : ");
+            chaineFormatée = string.Format(format, 110, "2ème", "2010-2011");
+            WriteLine(chaineFormatée);
+            chaineFormatée = "Nb élèves : " + 110.ToString().PadRight(5) + " Année : " + "2ème".PadRight(5) + " Année universitaire : " + "2010-2011".PadLeft(15);
+            WriteLine(chaineFormatée);
+            chaineFormatée = "Nb élèves : " + 98.ToString().PadRight(5) + " Année : " + "2ème".PadRight(5) + " Année universitaire : " + "2010-2011".PadLeft(15);
+            WriteLine(chaineFormatée);
+
+            //String Interpolation
+            WriteLine("\n STRING INTERPOLATION avec $");
+            WriteLine($"Il y a {135} élèves inscrits en {"1ère"} année à l'IUT pour l'année scolaire {"2016 - 2017"}");
+
+            //comparaison de string
+            WriteLine("\n COMPARAISON DE STRING");
+            //equality comparison
+            WriteLine($"\"yaha\" == \"YAHA\" ? " + ("yaha" == "YAHA"));
+            WriteLine($"\"yaha\".Equals(\"YAHA\") ? " + ("yaha".Equals("YAHA")));
+            WriteLine($"string.Equals(\"yaha\", \"YAHA\") ? " + string.Equals("yaha", "YAHA"));
+            WriteLine($"\"yaha\".Equals(\"YAHA\", StringComparison.CurrentCultureIgnoreCase) ? " + ("yaha".Equals("YAHA", StringComparison.CurrentCultureIgnoreCase)));
+            WriteLine($"string.Equals(\"yaha\", \"YAHA\", StringComparison.CurrentCultureIgnoreCase) ? " + string.Equals("yaha", "YAHA", StringComparison.CurrentCultureIgnoreCase));
+
+            WriteLine($"string.Equals(\"éèàô\", \"eeao\") ? " + string.Compare("éèàô", "eeao", StringComparison.CurrentCultureIgnoreCase));
+
+        }
+    }
+}

p02_Fondamentaux/ex_006_001_string/ex_006_001_string.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_006.0.6_string</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_006.0.6_string</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_006_002_StringBuilder/Program.cs

@@ -0,0 +1,75 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-22
+//
+// ========================================================================
+
+using System;
+using System.Text;
+using static System.Console;
+
+namespace ex_006_002_StringBuilder
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            WindowWidth += 15;
+            WindowHeight = LargestWindowHeight;
+
+            Write("STRING BUILDER : version ");
+            BackgroundColor = ConsoleColor.DarkBlue;
+            ForegroundColor = ConsoleColor.Yellow;
+            Write("mutable");
+            ResetColor();
+            WriteLine(" de string");
+
+            //construction
+            WriteLine("\n CONSTRUCTION");
+            WriteLine("à l'aide d'un string : StringBuilder s1 = new StringBuilder(\"Bonjour\");");
+            StringBuilder s1 = new StringBuilder("Bonjour");
+            WriteLine(s1.ToString());
+            WriteLine("à l'aide d'une sous-chaîne d'un string : s1 = new StringBuilder(\"Bonjour\", 0, 3, 3);");
+            s1 = new StringBuilder("Bonjour", 0, 3, 3);
+            WriteLine(s1);
+
+            //manipuler les string builder
+            WriteLine("\n MANIPULER LES STRING BUILDER");
+            //append
+            WriteLine("APPEND");
+            StringBuilder s7 = new StringBuilder().Append("Jim").Append(" ").Append("Raynor");
+            WriteLine($"new StringBuilder().Append(\"Jim\").Append(\" \").Append(\"Raynor\"); contient {s7}");
+            WriteLine("APPEND FORMAT");
+            string format = "Il y a {0} élèves inscrits en {1} année à l'IUT pour l'année scolaire {2}";
+            WriteLine("Le format : {0}", format);
+            StringBuilder s9 = new StringBuilder().AppendFormat(format, 110, "2ème", "2011-2012");
+            WriteLine("new StringBuilder().AppendFormat(format, 110, \"2ème\", \"2011-2012\"); vaut :\n{0}", s9);
+            WriteLine();
+
+            //insert, remove, replace
+            StringBuilder s8 = new StringBuilder("Jim Raynor");
+            WriteLine("StringBuilder s8 = new StringBuilder(\"Jim Raynor\");");
+            WriteLine("REMOVE");
+            s8.Remove(2, 3);
+            WriteLine("s8.Remove(2, 3) vaut {0}", s8);
+            WriteLine("INSERT");
+            s8.Insert(2, "m R");
+            WriteLine("s8.Insert(2, \"m R\") vaut {0}", s8);
+            WriteLine("CLEAR");
+            s8.Clear();
+            WriteLine("s8.Clear()");
+            WriteLine("REPLACE");
+            WriteLine("s8.Append(\"Les chaussettes de l'archiduchesse\");");
+            s8.Append("Les chaussettes de l'archiduchesse");
+            s8.Replace(" ", "_");
+            WriteLine("s8.Replace(\" \", \"_\") vaut {0}", s8);
+        }
+    }
+}

p02_Fondamentaux/ex_006_002_StringBuilder/ex_006_002_StringBuilder.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_006_002_StringBuilder</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_006_002_StringBuilder</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_007_001_enum/Program.cs

@@ -0,0 +1,108 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+namespace ex_007_001_enum
+{
+    class Program
+    {
+        /// <summary>
+        /// voici une énumération.
+        /// public n'est pas obligatoire. S'il est indiqué, l'énumération est utilisable en dehors de la classe.
+        /// </summary>
+        [Flags]//pas obligatoire mais conseillé pour améliorer le ToString de l'enum dans le cas des combinaisons
+        public enum MusicType : byte
+        {
+            Classic = 1,            //00000001
+            Jazz = 2,               //00000010
+            Pop = 4,                //00000100
+            Rock = 8,               //00001000
+            //on peut rajouter des combinaisons d'enum : ici, PopRock est à la fois Pop et Rock
+            //il faut pour cela que toutes les valeurs d'enum puissent s'exclure mutuellement
+            PopRock = Pop | Rock    //00001100
+        }
+
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            //déclaration d'une variable de type MusicType
+            MusicType mMuzik;
+            //affectation d'une valeur possible à cette variable
+            mMuzik = MusicType.Jazz;
+            WriteLine(mMuzik);
+
+            //un exemple d'utilisation
+            Write("la variable mMuzik est de type : ");
+            switch (mMuzik)
+            {
+                case MusicType.Classic:
+                    WriteLine("Classique"); break;
+                case MusicType.Jazz:
+                    WriteLine("Jazz"); break;
+                case MusicType.Pop:
+                    WriteLine("Pop"); break;
+                case MusicType.Rock:
+                    WriteLine("Rock"); break;
+            }
+            WriteLine();
+
+            //un enum peut être considéré comme un instance de la classe Enum
+            //exemple d'utilisation
+            WriteLine("liste des valeurs de l'énumération");
+            foreach (string s in Enum.GetNames(typeof(MusicType)))
+                WriteLine(s);
+            WriteLine();
+
+            //autre utilisation
+            Write("la variable mMuzik est de type : ");
+            switch (mMuzik)
+            {
+                case MusicType.Classic:
+                    WriteLine(MusicType.Classic.ToString()); break;
+                case MusicType.Jazz:
+                    WriteLine(MusicType.Jazz.ToString()); break;
+                case MusicType.Pop:
+                    WriteLine(MusicType.Pop.ToString()); break;
+                case MusicType.Rock:
+                    WriteLine(MusicType.Rock.ToString()); break;
+            }
+            WriteLine();
+
+            //combinaison
+            mMuzik = MusicType.Jazz | MusicType.Rock; // 00001010
+            WriteLine(mMuzik); //si vous utilisez [Flags], affiche "Jazz, Rock", sinon, affiche "10"
+            //on veut vérifier que mMuzik est du Jazz :
+            if ((mMuzik & MusicType.Jazz) != 0) //mMuzik & Jazz = 00001010 & 00000010 = 00000010 != 0 c'est donc du jazz (entre autres)
+            {
+                WriteLine("Includes Jazz");
+            }
+            //on veut vérifier que mMuzik n'est pas de la Pop :
+            if ((mMuzik & MusicType.Pop) == 0) //mMuzik & Pop = 00001010 & 00000100 = 00000000 == 0 ce n'est donc pas de la Pop
+            {
+                WriteLine("pas pop");
+            }
+            //finalement on veut rajouter Pop
+            mMuzik |= MusicType.Pop; //00001010 | 00000100 = 00001110
+            if ((mMuzik & MusicType.Pop) != 0) //mMuzik & Pop = 00001110 & 00000100 = 00000100 != 0 c'est donc de la Pop
+            {
+                WriteLine("pop");
+            }
+            //et enlever Jazz
+            mMuzik ^= MusicType.Jazz; //00001110 ^ 00000010 = 00001100
+            if ((mMuzik & MusicType.Jazz) == 0) //mMuzik & Jazz = 00001100 & 00000010 = 00000000 == 0 ce n'est donc plus du jazz
+            {
+                WriteLine("pas jazz");
+            }
+        }
+    }
+}

p02_Fondamentaux/ex_007_001_enum/ex_007_001_enum.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_007_001_enum</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_007_001_enum</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_008_001_if_else/Program.cs

@@ -0,0 +1,78 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_008_001_if_else
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            int vitesseMax = 70;
+            WriteLine($"La vitesse maximum autorisée est de {vitesseMax} km/h");
+            Random random = new Random();
+            int vitesse = random.Next(50, 150);
+            WriteLine($"Vous roulez à {vitesse} km/h");
+
+            if (vitesse <= vitesseMax)
+            {
+                WriteLine("Vous ne dépassez pas la vitesse maximum");
+            }
+            else
+            {
+                WriteLine("Vous dépassez la vitesse maximum autorisée");
+                if (vitesse < vitesseMax + 20)
+                {
+                    WriteLine("L'amende forfaitaire s'élève à 68 euros");
+                    WriteLine("1 point est retiré du permis de conduire");
+                }
+                else if (vitesse < vitesseMax + 50)
+                {
+                    WriteLine("L'amende forfaitaire s'élève à 135 euros");
+                    if (vitesse < vitesseMax + 30)
+                    {
+                        WriteLine("2 points sont retirés du permis de conduire");
+                    }
+                    else if (vitesse < vitesseMax + 40)
+                    {
+                        WriteLine("3 points sont retirés du permis de conduire");
+                    }
+                    else if (vitesse < vitesseMax + 50)
+                    {
+                        WriteLine("4 points sont retirés du permis de conduire");
+
+                    }
+                }
+                else
+                {
+                    WriteLine("L'amende fofaitaire s'élève à 1500 euros");
+                    WriteLine("6 points sont retirés du permis de conduire");
+                }
+                if (vitesse >= vitesseMax + 30)
+                {
+                    WriteLine("Jusqu'à 3 ans de suspension de permis de conduire");
+                    if (vitesse >= vitesseMax + 40)
+                    {
+                        if (vitesse >= vitesseMax + 50)
+                        {
+                            WriteLine("Obligation d'accomplir, à ses frais, un stage de sensibilisation à la sécurité routière, confiscation du véhicule dont le prévenu s'est servi pour commettre l'infraction, s'il en est propriétaire.");
+                        }
+                        WriteLine("Une suspension immédiate du permis de conduire s'ajoute aux sanctions ci-dessus");
+                    }
+                }
+            }
+        }
+    }
+}

p02_Fondamentaux/ex_008_001_if_else/ex_008_001_if_else.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_008_001_if_else</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_008_001_if_else</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_008_002_switch/Program.cs

@@ -0,0 +1,77 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_008_002_switch
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            Random random = new Random();
+            int i = random.Next(6);
+
+            switch (i)
+            {
+                case 0:
+                    WriteLine("i vaut 0"); //1 ou plusieurs instruction puis break; ("obligatoire")
+                    break;
+                case 1:
+                case 2:
+                    WriteLine("i vaut 1 ou 2"); // pour que deux case partagent les mêmes instructions,
+                    break;                              // il faut que le premier soit vide et sans break;
+                case 3:
+                    WriteLine("goto à la place de break"); //si le case n'est pas vide, je peux quand même rejoindre un autre case,
+                    goto case 4;                                    // à l'aide d'un goto
+                case 4:
+                    WriteLine("i vaut 3 ou 4");
+                    break;
+                default:
+                    WriteLine("i vaut autre chose");
+                    break;
+            }
+
+            string[] jours = { "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche" };
+
+            string jour = jours[random.Next(jours.Length)];
+
+            //le switch fonctionne pour les chaînes de caractères !!!
+            switch (jour)
+            {
+                case "lundi":
+                    WriteLine($"J'aime pas le {jour}");
+                    break;
+                case "mardi":
+                    WriteLine($"Faut travailler un peu... le {jour}");
+                    break;
+                case "mercredi":
+                    WriteLine("Ah l'époque où on ne travaillait pas le mercredi !");
+                    break;
+                case "jeudi":
+                case "vendredi":
+                    goto case "mardi";
+                case "samedi":
+                    WriteLine("Vivement le weekend");
+                    break;
+                case "dimanche":
+                    WriteLine("Je travaillerai demain");
+                    break;
+                default:
+                    WriteLine("Quel jour on est !!!!????");
+                    break;
+            }
+        }
+    }
+}

p02_Fondamentaux/ex_008_002_switch/ex_008_002_switch.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_008_002_switch</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_008_002_switch</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_008_003_ternary_operator/Program.cs

@@ -0,0 +1,37 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+// Mise à jour   : 2017-09-18
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_008_003_ternary_operator
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            //L'opérateur conditionnel (conditional operator), aussi appelé opérateur ternaire (ternary operator),
+            //est le seul opérateur à prendre trois opérandes.
+            //Il a la forme suivante : c ? a : b
+            //où c est la condition,
+            //   a est la valeur de retour si c est true
+            //   b est la valeur de retour si c est false
+
+            WriteLine("Rentrez quelque chose, je vous dirai si c'est un nombre ou non :");
+            string chaine = ReadLine();
+            bool condition = float.TryParse(chaine, out var nombre);
+            WriteLine(condition ? $"j'ai reconnu le nombre : {nombre.ToString()}" : "ce que vous avez entré n'est pas un nombre");
+        }
+    }
+}

p02_Fondamentaux/ex_008_003_ternary_operator/ex_008_003_ternary_operator.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_008_003_ternary_operator</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_008_003_ternary_operator</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_008_004_null_operators/Program.cs

@@ -0,0 +1,74 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_008_004_null_operators
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            //C# fournit deux opérateurs pour simplifier le travail avec les nulls
+
+            //Null-coalescing operator : ??
+            //"si l'opérande n'est pas nulle, rends-la moi ; sinon, donne-moi la valeur par défaut que je t'ai renseignée"
+            WriteLine("NULL-COLAESCING OPERATOR \n");
+            WriteLine("s est une chaîne de caractères nulle");
+            WriteLine("J'affiche s ?? \"rien\", c'est-à-dire que si s est null, on affichera la valeur par défaut : rien, sinon on affichera la valeur de s");
+            string s = null;
+            string result = s ?? "rien";
+            WriteLine($"-> {result}");
+
+            WriteLine();
+            WriteLine("rentrez du texte, que je stockerai dans s :");
+            s = ReadLine();
+            WriteLine("J'affiche s ?? \"rien\", c'est-à-dire que si s est null, on affichera la valeur par défaut : rien, sinon on affichera la valeur de s");
+            result = s ?? "rien";
+            WriteLine($"-> {result}");
+            WriteLine();
+
+            //Elvis Operator ou Null-conditional operator : ?.
+            //avec cet opérateur, pas besoin de tester si l'opérande est nulle avant d'appeler une méthode ou une propriété :
+            // si elle n'est pas nulle, fonctionne comme le .
+            // si elle est nulle, renvoie null (sans lancer l'exception NullReferenceException)
+
+            WriteLine("Elvis operator ou Null-Conditional operator \n");
+            WriteLine("s2 est une chaîne de caractères nulle");
+            WriteLine("Je veux stocker s2.ToUpper() dans s3, mais puisque s2 est nulle, ça lance une exception :");
+            string s2 = null;
+            string s3 = null;
+            try
+            {
+                s3 = s2.ToUpper();
+                WriteLine(s3 != null ? s3 : "null");
+            }
+            catch(NullReferenceException exception)
+            {
+                WriteLine(exception);
+            }
+            WriteLine();
+
+            WriteLine("Maintenant je veux stocker s2?.ToUpper() dans s3. Puisque s2 est nulle, null est stocké dans s3 mais sans lancer d'exception.");
+            s3 = s2?.ToUpper();
+            WriteLine(s3 != null ? s3 : "null");
+            WriteLine();
+            WriteLine("\nmême chose avec le texte que vous allez rentrer :");
+            s2 = ReadLine();
+            s3 = s2?.ToUpper();
+            WriteLine(s3 != null ? s3 : "null");
+
+        }
+    }
+}

p02_Fondamentaux/ex_008_004_null_operators/ex_008_004_null_operators.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_008_004_null_operators</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_008_004_null_operators</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_008_005_pattern_matching/Program.cs

@@ -0,0 +1,149 @@
+// ========================================================================
+//
+// Copyright (C) 2017-2018 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2017-09-19
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_008_005_pattern_matching
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            //C# 7.0 introduit le pattern matching, dont l'objectif est de permettre de "tester" si un objet respecte certaines conditions de "forme".
+            //En C# 7.0, on trouve pour le moment trois types de patterns :
+            //  - constant patterns : qui permettent de tester si un objet est égal à une constante
+            //  - type patterns : qui permettent de tester si un objet est de type T, et si c'est le cas, de le tester dans une nouvelle variable
+            //  - var patterns : qui permettent de pacer un objet dans une nouvelle variable du même type
+            //Les patterns matching devraient certainement être beaucoup plus utilisés dans les versions futures de C#.
+            //Pour le moment, on en trouve deux cas d'utilisation majeurs : les expressions "is" et les clauses "case" dans les switch.
+
+            //PATTERN MATCHING AND IS-EXPRESSIONS
+            void DisplayPrice(object price)
+            {
+                //constant pattern dans une is-expression avec comparaison à null
+                if (price is null)
+                {
+                    WriteLine("Vous avez rentré une valeur nulle");
+                    return;
+                }
+
+                //var pattern dans une is-expression
+                if (price is var price2)
+                {
+                    WriteLine($"price2 est de type : {price2.GetType().Name} ; price2 a pour valeur : {price2}");
+                }
+
+                //type pattern dans une is-expression avec comparaison à un type numérique
+                if (!(price is float p))
+                {
+                    WriteLine($"price n'est pas du bon type. Type attendu : Single, Type utilisé : {price.GetType().Name}");
+                    return;
+                }
+                WriteLine($"Vous avez rentré : {p:0.00} euros");
+            }
+
+            DisplayPrice(null);
+            DisplayPrice(32.0f);
+            DisplayPrice("coucou");
+            DisplayPrice(3);
+
+            //var-pattern : on a une copie des variables, donc attention aux types références !
+            void TestVarPattern(Nounours original)
+            {
+                WriteLine("Avant var pattern:");
+                WriteLine($"original : {original}");
+                if (original is var copie)
+                {
+                    copie.Nom = "Chucky";
+                    copie.NbPoils = 4;
+                }
+
+                WriteLine("Après var pattern:");
+                WriteLine($"original : {original}");
+                WriteLine($"copie : {copie}");
+            }
+
+            TestVarPattern(new Nounours { Nom = "Gizmo", NbPoils = 123456789, Naissance = new DateTime(1984, 6, 8) });
+
+
+
+            //PATTERN MATCHING DANS UN SWITCH AVEC DES CASES ET DES CONDITIONS SUPPLEMENTAIRES
+
+            Nounours[] nounours =
+            {
+                new Nounours { Nom = "Gizmo", NbPoils = 123456789, Naissance = new DateTime(1984, 6, 8) },
+                new NounoursProf { Nom = "Yoda", NbPoils = 4, Naissance = new DateTime(1980, 5, 21), Matière="How to become a Jedi?" },
+                new NounoursElève { Nom = "Ewok", NbPoils = 98989898, Naissance = new DateTime(1983, 5, 25), FormationSuivie="How to destroy an AT-ST?" },
+                new NounoursElève { Nom = "Chucky", NbPoils = 2, Naissance = new DateTime(1988, 11, 9), FormationSuivie="How to become naughty?" },
+                null
+            };
+
+            void TestPatternMatchingInASwitch(Nounours monNounours)
+            {
+                //Il est possible de faire un switch sur n'importe quel type désormais
+                //La nouvelle gestion du switch fait que maintenant, l'ordre des clauses "case" a de l'importance (dans l'exemple ci-dessous, si on mettait la 2ème avant la 1ère,
+                //la 1ère ne serait jamais exécutée). Heureusement, le compilateur vous aidera a trouvé les cas qui ne seront jamais exécutés !
+                switch (monNounours)
+                {
+                    //type pattern avec une condition (when)
+                    case NounoursElève élève when (élève.Naissance < new DateTime(1985, 1, 1)):
+                        WriteLine($"{élève.Nom} est un vieil élève apprenant : {élève.FormationSuivie}");
+                        break;
+                    //type pattern sans condition
+                    case NounoursElève élève:
+                        WriteLine($"{élève.Nom} est un élève apprenant : {élève.FormationSuivie}");
+                        break;
+                    //type pattern
+                    case NounoursProf prof:
+                        WriteLine($"{prof.Nom} est un prof qui enseigne : {prof.Matière}");
+                        break;
+                    //même s'il y a un autre case plus bas (comme dans cet exemple), le default est toujours évalué en dernier, pour des raisons de compatibilité.
+                    //Pour une meilleure lisibilité, ne faites donc pas comme dans cet exemple : laissez le default à la fin
+                    default:
+                        WriteLine($"{monNounours.Nom} est un Nounours comme un autre, sans histoire particulière...");
+                        break;
+                    //constant pattern
+                    case null:
+                        WriteLine($"Attention, ce Nounours est null ! (nom du paramètre : {nameof(monNounours)})");
+                        break;
+                }
+            }
+
+            foreach (var n in nounours)
+            {
+                TestPatternMatchingInASwitch(n);
+            }
+        }
+    }
+
+    class Nounours
+    {
+        public string Nom { get; set; }
+        public int NbPoils { get; set; }
+        public DateTime Naissance { get; set; }
+
+        public override string ToString()
+        {
+            return $"{Nom} a {NbPoils} poils et est né en {Naissance.Year}";
+        }
+    }
+
+    class NounoursProf : Nounours
+    {
+        public string Matière { get; set; }
+    }
+
+    class NounoursElève : Nounours
+    {
+        public string FormationSuivie { get; set; }
+    }
+}

p02_Fondamentaux/ex_008_005_pattern_matching/ex_008_005_pattern_matching.csproj

@@ -0,0 +1,6 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_009_001_bouclesIteratives/Program.cs

@@ -0,0 +1,74 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_009_001_bouclesIteratives
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            string[] jours = { "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche" };
+
+            //BOUCLE WHILE
+            WriteLine("boucle while");
+            int i = 0;
+            while (i < jours.Length)
+            {
+                Write($"{jours[i]} ");
+                i++;
+            }
+
+            WriteLine();
+
+            //BOUCLE DO-WHILE
+            WriteLine("boucle do-while");
+            int j = 0;
+            do
+            {
+                Write($"{jours[j]} ");
+                j++;
+            }
+            while (j < jours.Length);
+
+            WriteLine();
+
+            //BOUCLE FOR
+            WriteLine("boucle for");
+            for (int k = 0; k < jours.Length; k++)
+            {
+                Write($"{jours[k]} ");
+            }
+
+            WriteLine();
+
+            //BOUCLE FOREACH
+            WriteLine("boucle foreach");
+            foreach (string jour in jours)
+            {
+                Write($"{jour} ");
+            }
+
+            WriteLine();
+
+            foreach (string jour in jours)
+            {
+                if (jour == "Mercredi")
+                    continue; //continue est autorisé : passe directement à l'itération suivante 
+                if (jour == "Samedi")
+                    break;    //break est autorisé : arrête la boucle
+                WriteLine(jour);
+            }
+        }
+    }
+}

p02_Fondamentaux/ex_009_001_bouclesIteratives/ex_009_001_bouclesIteratives.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_009_001_bouclesIteratives</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_009_001_bouclesIteratives</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_010_001_methodParametersAndModifiers/Program.cs

@@ -0,0 +1,183 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+// Mise à jour   : 2017-09-28
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_010_001_methodParametersAndModifiers
+{
+    class ExFunct
+    {
+        //passage d'arguments par valeur
+        public int Somme(int a, int b)
+        {
+            int result = a + b;
+            //celui qui appelle cette méthode ne pourra pas voir ces changements
+            //car a et b sont ici des copies locales des paramètres qu'il a passés
+            a++;
+            b++;
+            return result;
+        }
+
+        //passage d'argument par référence (notez le mot-clé ref)
+        public int SommeRef(ref int a, ref int b)
+        {
+            int result = a + b;
+            //celui qui appelle cette méthode verra les deux paramètres qu'il a passés
+            //modifiés par celle-ci, car ils sont passés par référence
+            a++;
+            b++;
+            return result;
+        }
+
+        //passage de tableaux en argument (pas besoin de préciser ref, le tableau en est une)
+        public int SommeTab(int[] tab)
+        {
+            int result = 0;
+            for (int i = 0; i < tab.Length; i++)
+            {
+                //celui qui appelle cette méthode verra les valeurs du tableau passé en paramètre
+                //modifiées par la méthode, car un tableau est toujours passé par référence
+                //(un tableau EST un type REFERENCE)
+                result += tab[i];
+                tab[i]++;
+            }
+            return result;
+        }
+
+        //passage d'argument out : indique que la variable est initialisée par la fonction appelée (notez le mot-clé out)
+        public void SommeOut(int a, int b, out int result)
+        {
+            //celui qui appelle cette méthode peut donner result sans l'initialiser
+            //le mot-clé out garantit que ce paramètre sera initialisé dans la méthode
+            result = a + b;
+        }
+
+        //passage d'arguments en nombre indéterminé, en dernier paramètre de la méthode uniquement
+        public int SommeParams(params int[] ints)
+        {
+            //l'utilisateur de la méthode n'a pas besoin de préciser params
+            //en revanche, il peut passer autant d'arguments de type int qu'il le souhaite.
+            //À l'intérieur de la méthode, ces arguments sont traités comme un tableau d'entiers,
+            //mais tous les éléments de ce tableau sont copiés par valeur.
+            int result = 0;
+            for (int i = 0; i < ints.Length; i++)
+            {
+                result += ints[i];
+                ints[i]++;
+            }
+            return result;
+        }
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            ExFunct f = new ExFunct();
+            int a = 2;
+            int b = 3;
+            WriteLine("f.Somme(a, b)");
+            WriteLine($"a (avant) = {a}");
+            WriteLine($"b (avant) = {b}");
+            WriteLine($"résultat : {f.Somme(a, b)}"); //passage d'arguments par valeur
+            WriteLine($"a (après) = {a}");
+            WriteLine($"b (après) = {b}");
+            WriteLine();
+
+            WriteLine("f.SommeRef(ref a, ref b)");
+            WriteLine($"a (avant) = {a}");
+            WriteLine($"b (avant) = {b}");
+            WriteLine($"résultat : {f.SommeRef(ref a, ref b)}");//passage d'argument par référence (notez le mot clé ref) --> a est modifié par la fonction
+            WriteLine($"a (après) = {a}");
+            WriteLine($"b (après) = {b}");
+            WriteLine();
+
+            WriteLine("tableaux");
+            int[] t = { 1, 2, 3 };
+            Write("tableau t (avant) : ");
+            foreach (int i in t) Write($"{i} ");
+            WriteLine();
+            f.SommeTab(t); //passage de tableau en argument (pas besoin de ref, car c'est est une).
+            WriteLine("f.SommeTab(t);");
+            Write("tableau t (après) : ");
+            foreach (int i in t) Write($"{i} ");
+            WriteLine();
+            WriteLine();
+
+            int c;
+            WriteLine("f.SommeOut(a, b, out c);");
+            WriteLine($"a (avant) = {a}");
+            WriteLine($"b (avant) = {b}");
+            WriteLine("c est non assigné");
+            f.SommeOut(a, b, out c);
+            WriteLine($"résultat : {c}"); //passage d'argument out. c n'est pas initialisé, et on utilise le mot clé out
+            WriteLine($"a (après) = {a}");
+            WriteLine($"b (après) = {b}");
+            WriteLine($"c (après) = {c}");
+            WriteLine();
+
+            //Dans l'exemple ci-dessus de l'utilisation des paramètres out, il est nécessaire de déclarer c avant son utilisation :
+            //int c;
+            //f.SommeOut(a, b, out c);
+            //Depuis C# 7.0, l'utilisation a été simplifiée : vous pouvez maintenant déclarer la variable lors de son utilisation :
+            //f.SommeOut(a, b, out int c2);
+            //La portée de la variable est alors le bloc contenant l'instruction prenant le paramètre out en paramètre.
+
+            WriteLine("f.SommeOut(a, b, out int c2);");
+            WriteLine($"a (avant) = {a}");
+            WriteLine($"b (avant) = {b}");
+            WriteLine("c2 est non assigné et déclaré lors de l'appel de la méthode SommeOut");
+            f.SommeOut(a, b, out int c2);
+            WriteLine($"résultat : {c2}"); //passage d'argument out. c2 n'est pas initialisé, et on utilise le mot clé out
+            WriteLine($"a (après) = {a}");
+            WriteLine($"b (après) = {b}");
+            WriteLine($"c2 (après) = {c2}");
+            WriteLine();
+
+            //Il est également possible d'utiliser var, tant qu'il n'y a pas de conflit (surcharge de méthodes), ce qui rend l'utilisation encore plus simple
+            WriteLine("f.SommeOut(a, b, out var c3);");
+            WriteLine($"a (avant) = {a}");
+            WriteLine($"b (avant) = {b}");
+            WriteLine("c3 est non assigné et déclaré lors de l'appel de la méthode SommeOut");
+            f.SommeOut(a, b, out var c3);
+            WriteLine($"résultat : {c3}"); //passage d'argument out. c3 n'est pas initialisé, et on utilise le mot clé out
+            WriteLine($"a (après) = {a}");
+            WriteLine($"b (après) = {b}");
+            WriteLine($"c3 (après) = {c3}");
+            WriteLine();
+
+            //Enfin, il est également possible de préciser qu'on veut ignorer une variable out avec _ (discard variables)
+            WriteLine("f.SommeOut(a, b, out _);");
+            WriteLine($"a (avant) = {a}");
+            WriteLine($"b (avant) = {b}");
+            WriteLine("on ne souhaite pas récupérer le paramètre en out");
+            f.SommeOut(a, b, out _);
+            WriteLine($"a (après) = {a}");
+            WriteLine($"b (après) = {b}");
+            WriteLine();
+
+            WriteLine("f.SommeParams(a, b, c)");
+            WriteLine($"a (avant) = {a}");
+            WriteLine($"b (avant) = {b}");
+            WriteLine($"c (avant) = {c}");
+            //passage d'arguments en nombre indéterminé
+            WriteLine($"résultat : {f.SommeParams(a, b, c)}");
+            WriteLine($"a (après) = {a}");
+            WriteLine($"b (après) = {b}");
+            WriteLine($"c (après) = {c}");
+            WriteLine();
+        }
+    }
+}

p02_Fondamentaux/ex_010_001_methodParametersAndModifiers/ex_010_001_methodParametersAndModifiers.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_010_001_methodParametersAndModifiers</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_010_001_methodParametersAndModifiers</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_010_002_optionalParameters/Program.cs

@@ -0,0 +1,45 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_010_002_optionalParameters
+{
+    class ExFunct
+    {
+        //arguments optionnels (et arguments nommés)
+        public string SomeString(int x = 1, int y = 2, int z = 3)
+        {
+            return string.Format($"x : {x}, y : {y}, z : {z}");
+        }
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            ExFunct f = new ExFunct();
+
+            WriteLine("arguments optionnels et arguments nommés");
+            WriteLine($"SomeString() : {f.SomeString()}");
+            WriteLine($"SomeString(4) : {f.SomeString(4)}");
+            WriteLine($"SomeString(4, 5) : {f.SomeString(4, 5)}");
+            WriteLine($"SomeString(4, 5, 6) : {f.SomeString(4, 5, 6)}");
+            WriteLine($"SomeString(y:5, z:6) : {f.SomeString(y: 5, z: 6)}");
+            WriteLine($"SomeString(y:5) : {f.SomeString(y: 5)}");
+            //WriteLine($"SomeString(y:5, 6) : {f.SomeString(y:5, 6)}");
+            //ne compile pas (pas d'arguments positionnels après un argument nommé)
+        }
+    }
+}

p02_Fondamentaux/ex_010_002_optionalParameters/ex_010_002_optionalParameters.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_010_002_optionalParameters</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_010_002_optionalParameters</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_010_003_interets_des_optionalparameters/Program.cs

@@ -0,0 +1,122 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using static System.Console;
+
+//cet exemple montre trois manières différentes de gérer les paramètres par défaut
+namespace ex_010_003_interets_des_optionalparameters
+{
+    class C1
+    {
+        /// <summary>
+        /// une méthode qui gère les paramètres remplis avec null : 
+        /// l'utilisateur doit toujours renseigner chaque paramètre
+        /// </summary>
+        /// <param name="s1"></param>
+        /// <param name="s2"></param>
+        /// <param name="s3"></param>
+        /// <returns></returns>
+        public static string Method(string s1, string s2, string s3)
+        {
+            if (s1 == null)
+            {
+                s1 = "nothing";
+            }
+            if (s2 == null)
+            {
+                s2 = "nothing";
+            }
+            if (s3 == null)
+            {
+                s3 = "nothing";
+            }
+            return string.Format($"{s1} + {s2} + {s3}");
+        }
+    }
+
+    class C2
+    {
+        /// <summary>
+        /// la méthode Method possède trois overload afin de gérer des valeurs par défaut
+        /// Risque de confusion et impossibilité de faire toutes les combinaisons.
+        /// </summary>
+        /// <param name="s1"></param>
+        /// <param name="s2"></param>
+        /// <param name="s3"></param>
+        /// <returns></returns>
+        public static string Method(string s1, string s2, string s3)
+        {
+            return string.Format($"{s1} + {s2} + {s3}");
+        }
+        public static string Method(string s1, string s2)
+        {
+            return string.Format($"{s1} + {s2} + nothing");
+        }
+        public static string Method(string s)
+        {
+            return string.Format($"{s} + nothing + nothing");
+        }
+    }
+
+    class C3
+    {
+        /// <summary>
+        /// avec les paramètres optionnels, toutes les combinaisons sont possibles et une seule méthode suffit.
+        /// Un seul inconvénient : les noms des paramètres font maintenant partis de l'API
+        /// </summary>
+        /// <param name="s1"></param>
+        /// <param name="s2"></param>
+        /// <param name="s3"></param>
+        /// <returns></returns>
+        public static string Method(string s1 = "nothing", string s2 = "nothing", string s3 = "nothing")
+        {
+            return string.Format($"{s1} + {s2} + {s3}");
+        }
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            WriteLine("Méthode 1 : tous les champs doivent toujours être renseignés");
+            WriteLine("C1.Method(\"a\", \"b\", \"c\")");
+            WriteLine(C1.Method("a", "b", "c"));
+            WriteLine("C1.Method(\"a\", \"b\", null)");
+            WriteLine(C1.Method("a", "b", null));
+            WriteLine("C1.Method(\"a\", null, null)");
+            WriteLine(C1.Method("a", null, null));
+            WriteLine("C1.Method(null, \"b\", null)");
+            WriteLine(C1.Method(null, "b", null));
+
+            WriteLine();
+            WriteLine("Méthode 2 : Overloads");
+            WriteLine("C2.Method(\"a\", \"b\", \"c\")");
+            WriteLine(C2.Method("a", "b", "c"));
+            WriteLine("C2.Method(\"a\", \"b\")");
+            WriteLine(C2.Method("a", "b"));
+            WriteLine("C2.Method(\"a\")");
+            WriteLine(C2.Method("a"));
+
+            WriteLine();
+            WriteLine("Méthode 3 : optional parameters and named parameters");
+            WriteLine("C3.Method(\"a\", \"b\", \"c\")");
+            WriteLine(C3.Method("a", "b", "c"));
+            WriteLine("C3.Method(\"a\", \"b\")");
+            WriteLine(C3.Method("a", "b"));
+            WriteLine("C3.Method(\"a\")");
+            WriteLine(C3.Method("a"));
+            WriteLine("C3.Method(s2:\"b\")");
+            WriteLine(C3.Method(s2: "b"));
+        }
+    }
+}

p02_Fondamentaux/ex_010_003_interets_des_optionalparameters/ex_010_003_interets_des_optionalparameters.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_010_003_interets_des_optionalparameters</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_010_003_interets_des_optionalparameters</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_012_001_nullableTypes/Program.cs

@@ -0,0 +1,51 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_012_001_nullableTypes
+{
+    class Program
+    {
+        //les types référence peuvent représenter une valeur non-existante (null reference)
+        //par contre, les valeurs elles, ne le peuvent pas : int i = null n'est pas autorisé
+        //En C# on peut quand même le faire, à l'aide des nullable types
+        static void Main(string[] args)
+        {
+            int? i = null;
+            WriteLine("int? i = null");
+            Write("i == null ? ");
+            WriteLine(i == null);
+            WriteLine($"i.HasValue {i.HasValue}");
+            WriteLine($"i or default : {i.GetValueOrDefault()}");
+            i = 2;
+            WriteLine("i = 2");
+            Write("i == null ? ");
+            WriteLine(i == null);
+            WriteLine($"i.HasValue {i.HasValue}");
+            WriteLine($"i or default : {i.GetValueOrDefault()}");
+            WriteLine($"i.Value : {i.Value}");
+
+            //l'opérateur ?? est le null coalescing operator
+            int? x = null;
+            int y = x ?? 5; // y vaut 5 car x est null
+            int? a = 1;
+            int? b = 2;
+            int? z = x ?? a ?? b; // y vaut 1 car a est la première valeur non nulle
+            int? c = null;
+            int? w = x ?? c ?? b; // y vaut 2 car b est la première valeur non nulle
+
+
+        }
+    }
+}
+

p02_Fondamentaux/ex_012_001_nullableTypes/ex_012_001_nullableTypes.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_012_001_nullableTypes</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_012_001_nullableTypes</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_013_001_FormattingParsingNumEtBool/Program.cs

@@ -0,0 +1,174 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using System;
+using System.Text;
+using static System.Console;
+
+namespace ex_013_001_FormattingParsingTypesNumeriquesEtBool
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = Encoding.Unicode;
+            //Formatage avec ToString
+            bool b = true;
+            string s = b.ToString();
+            WriteLine($"b vaut {s}");
+
+            int i = 123, j = 1234, k = 12345;
+            s = i.ToString();
+            WriteLine($"i vaut {i}");
+
+            WriteLine();
+
+            WriteLine("FORMATS STANDARDS");
+            //il existe énormément de variantes :
+            //Format standards
+            float f = 12345.6789f;
+            float g = 0.00000006f;
+            float h = 123456789.123f;
+            WriteLine($"f = {f.ToString()}");
+            WriteLine($"g = {g.ToString()}");
+            WriteLine($"h = {h.ToString()}");
+            WriteLine("\nG : notation exponentielle pour les grands ou les petits nombres");
+            WriteLine($"f.ToString(\"G\") : {f.ToString("G")}");
+            WriteLine($"g.ToString(\"G\") : {g.ToString("G")}");
+            WriteLine($"h.ToString(\"G\") : {h.ToString("G")}");
+
+            WriteLine("\nG3 : limite la notation à 3 chiffres maximum");
+            WriteLine($"f.ToString(\"G3\") : {f.ToString("G3")}");
+            WriteLine($"g.ToString(\"G3\") : {g.ToString("G3")}");
+            WriteLine($"h.ToString(\"G3\") : {h.ToString("G3")}");
+
+            WriteLine("\nF2 : arrondit à deux décimales");
+            WriteLine($"f.ToString(\"F2\") : {f.ToString("F2")}");
+            WriteLine($"g.ToString(\"F2\") : {g.ToString("F2")}");
+            WriteLine($"h.ToString(\"F2\") : {h.ToString("F2")}");
+
+            WriteLine("\nE : force la notation exponentielle (avec 6 chiffres, existe aussi avec E2, E3...");
+            WriteLine($"f.ToString(\"E\") : {f.ToString("E")}");
+            WriteLine($"g.ToString(\"E2 \") : {g.ToString("E2")}");
+            WriteLine($"h.ToString(\"E3\") : {h.ToString("E3")}");
+
+            WriteLine("\nC : currency (monnaie)");
+            WriteLine($"f.ToString(\"C\") : {f.ToString("C")}");
+            //number format info
+            System.Globalization.NumberFormatInfo monnaie = new System.Globalization.NumberFormatInfo();
+            monnaie.CurrencySymbol = "$$";
+            WriteLine($"g.ToString(\"C2 \") : {g.ToString("C2", monnaie)}");
+            //culture info
+            System.Globalization.CultureInfo info = new System.Globalization.CultureInfo("en-GB");
+            WriteLine($"h.ToString(\"C3\") : {h.ToString("C3", info)}");
+
+            WriteLine();
+
+            float p = 0.5349f, q = 0.53492f, r = 0.534923f;
+            WriteLine($"p = {p.ToString()}");
+            WriteLine($"q = {q.ToString()}");
+            WriteLine($"r = {r.ToString()}");
+            WriteLine("\nP : pourcentage");
+            WriteLine($"p.ToString(\"P\") : {p.ToString("P")}");
+            WriteLine($"a.ToString(\"P0 \") : {q.ToString("P0")}");
+            WriteLine($"r.ToString(\"P1\") : {r.ToString("P1")}");
+
+            WriteLine();
+
+            WriteLine($"i = {i.ToString()}");
+            WriteLine($"j = {j.ToString()}");
+            WriteLine($"k = {k.ToString()}");
+            WriteLine("\nD4 : pad left avec des 0 à gauche pour avoir au moins 4 chiffres");
+            WriteLine($"i.ToString(\"D4\") : {i.ToString("D4")}");
+            WriteLine($"j.ToString(\"D4\") : {j.ToString("D4")}");
+            WriteLine($"k.ToString(\"D4\") : {k.ToString("D4")}");
+
+            WriteLine();
+
+            //formats personnalisés
+            WriteLine("FORMATS PERSONNALISES");
+            float l = 123.456f;
+            WriteLine($"l = {l}");
+            WriteLine("\n .## limite à deux nombres max après la virgule");
+            WriteLine($"l.ToString(\".##\") : {l.ToString(".##")}");
+            WriteLine($"l.ToString(\".###\") : {l.ToString(".###")}");
+            WriteLine("\n .00 comme précédemment mais complète avec des 00");
+            WriteLine($"l.ToString(\".00\") : {l.ToString(".00")}");
+            WriteLine($"l.ToString(\".0000\") : {l.ToString(".0000")}");
+            WriteLine($"l.ToString(\"00.00\") : {l.ToString("00.00")}");
+            WriteLine($"l.ToString(\"0000.00\") : {l.ToString("0000.00")}");
+
+            int m = 5, n = -5, o = 0;
+            WriteLine();
+            WriteLine($"m = {m}");
+            WriteLine($"n = {n}");
+            WriteLine($"o = {o}");
+            WriteLine("\n +#;(#);zero rend le nombre \"+lenombre\" si positif, \"(lenombre)\" si négatif, \"zero\" si = 0");
+            WriteLine($"m.ToString(\"+#;(#);zero\") : {m.ToString("+#;(#);zero")}");
+            WriteLine($"n.ToString(\"+#;(#);zero\") : {n.ToString("+#;(#);zero")}");
+            WriteLine($"o.ToString(\"+#;(#);zero\") : {o.ToString("+#;(#);zero")}");
+
+            WriteLine();
+
+            //parsing
+            WriteLine("PARSING");
+
+            //méthodes statiques Parse, mais il vaut mieux la mettre dans un bloc try
+            WriteLine("i = int.Parse(\"yaha\");");
+            try
+            {
+                i = int.Parse("yaha");
+            }
+            catch (FormatException e)
+            {
+                WriteLine($"le parse a échoué (exception : {e.Message})");
+            }
+            WriteLine("i = int.Parse(123);");
+
+            try
+            {
+                i = int.Parse("123");
+            }
+            catch (FormatException e)
+            {
+                WriteLine($"le parse a échoué (exception : {e.Message})");
+            }
+            WriteLine(i);
+
+            //ou avec TryParse : rend true si a fonctionné et le résultat dans le paramètre out
+            //rend false si n'a pas fonctionné et il ne faut surtout pas regarder le résultat dans out
+            // pas d'exception de lancée
+            WriteLine("int.TryParse(\"yaha\", out i) + \" échec\"");
+            WriteLine($"{int.TryParse("yaha", out i)} échec");
+            WriteLine("int.TryParse(\"123\", out i) + \" \" + i");
+            WriteLine($"{int.TryParse("123", out i)} {i}");
+
+            //attention à la culture !
+            //WriteLine(double.Parse("1.23"));
+            WriteLine("double.Parse(\"1,23\")");
+            WriteLine(double.Parse("1,23"));
+            WriteLine("double.Parse(\"1.23\", System.Globalization.CultureInfo.InvariantCulture)");
+            WriteLine(double.Parse("1.23", System.Globalization.CultureInfo.InvariantCulture));
+
+            //on peut compléter le parsing avec des styles (flags)
+            //autoriser les parenthèses :
+            string stringToParse = "(123)";
+            WriteLine($"stringToParse = {stringToParse}");
+            WriteLine($"int.TryParse(stringToParse, out i) = {int.TryParse(stringToParse, out i)}");
+            WriteLine("int.TryParse(stringToParse, System.Globalization.NumberStyles.AllowParentheses, System.Globalization.CultureInfo.CurrentCulture, out i) = {0}\ni vaut = {1}",
+                int.TryParse(stringToParse,
+                             System.Globalization.NumberStyles.AllowParentheses,
+                             System.Globalization.CultureInfo.CurrentCulture,
+                             out i),
+                          i);
+        }
+    }
+}

p02_Fondamentaux/ex_013_001_FormattingParsingNumEtBool/ex_013_001_FormattingParsingNumEtBool.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_013_001_FormattingParsingNumEtBool</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_013_001_FormattingParsingNumEtBool</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p02_Fondamentaux/ex_013_002_FormattingParsingDateTime/Program.cs

@@ -0,0 +1,55 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_013_002_FormattingParsingDateTime
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+      
+            //Formatages standards et sensible à la culture
+            DateTime maintenant = DateTime.Now;
+
+            WriteLine(maintenant.ToString("d"));
+            WriteLine(maintenant.ToString("D"));
+            WriteLine(maintenant.ToString("t"));
+            WriteLine(maintenant.ToString("T"));
+            WriteLine(maintenant.ToString("f"));
+            WriteLine(maintenant.ToString("F"));
+            WriteLine(maintenant.ToString("g"));
+            WriteLine(maintenant.ToString("m"));
+            WriteLine(maintenant.ToString("y"));
+
+            //Formatage standard et insensible à la culture
+            WriteLine(maintenant.ToString("o")); //conseillé lors de l'écriture dans un fichier (pour garantir la lecture)
+
+            //Formatages personnalisés
+            WriteLine(maintenant.ToString("yyyy-MM-dd HH:mm:ss"));
+            WriteLine(maintenant.ToString("dd MMM yyyy HH:mm:ss"));
+            WriteLine(maintenant.ToString("ddd dd MMMM yyyy HH:mm:ss"));
+            WriteLine(maintenant.ToString("dddd dd MMMM yyyy HH:mm:ss"));
+
+            //le troisième argument de ParseExact permet de préciser la culture. Si null, alors prend la culture par défaut sur votre .NET
+            string dateString = maintenant.ToString("o");
+            DateTime dateParsée = DateTime.ParseExact(dateString, "o", null);
+            WriteLine(dateParsée);
+
+            dateString = maintenant.ToString("dddd dd MMMM yyyy HH:mm:ss");
+            dateParsée = DateTime.ParseExact(dateString, "dddd dd MMMM yyyy HH:mm:ss", null);
+            WriteLine(dateParsée);
+        }
+    }
+}

p02_Fondamentaux/ex_013_002_FormattingParsingDateTime/ex_013_002_FormattingParsingDateTime.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_013_002_FormattingParsingDateTime</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_013_002_FormattingParsingDateTime</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_014_001_namespace_et_nomDUneClasse/Program.cs

@@ -0,0 +1,63 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using static System.Console;
+
+// un namespace est un domaine dans lequel les types doivent être uniques
+// on peut organiser les types de manière hiérarchique, pour deux raisons :
+//      - éviter les conflits
+//      - les rendre plus faciles à trouver
+// par exemple : System.Collections.Generic.List<>
+
+//using permet d'importer un namespace et ses types (mais pas les namespaces qu'il contient)
+using Ext;
+using Ext.Milieu.Int;
+
+
+namespace Ext.Milieu.Int
+{
+    public class C1 { } //le vrai nom de C1 est : Ext.Milieu.Int.C1
+}
+
+namespace Ext
+{
+    namespace Milieu
+    {
+        namespace Int
+        {
+            public class C2 { } // le vrai nom de C2 est : Ext.Milieu.Int.C2
+        }
+        public class C3 { } //le vrai nom de C3 est : Ext.Milieu.C3
+    }
+    public class C4 { } // le vrai nom de C4 est : Ext.C4
+}
+
+namespace ex_014_001_namespace_et_nomDUneClasse
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            C4 b = new C4();
+            WriteLine(b.GetType());
+
+            C1 c = new C1();
+            WriteLine(c.GetType());
+
+            C2 d = new C2();
+            WriteLine(d.GetType());
+
+            Ext.Milieu.C3 a = new Ext.Milieu.C3();
+            WriteLine(a.GetType());
+        }
+    }
+}
+

p03_POO/ex_014_001_namespace_et_nomDUneClasse/ex_014_001_namespace_et_nomDUneClasse.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_014_001_namespace_et_nomDUneClasse</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_014_001_namespace_et_nomDUneClasse</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_014_002_typesImbriques/Program.cs

@@ -0,0 +1,50 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+namespace ex_014_002_typesImbriques
+{
+    public class UneClasse
+    {
+        class UneClasseImbriquéePrivée
+        {
+        }
+
+        private UneClasseImbriquéePrivée mMembre1;
+
+        //public UneClasseImbriquéePrivée mMembre2; //on ne peut pas avoir de membre autre que public de ce type, car la classe imbriquée est privée
+        //elle n'est donc pas visible en dehors de la classe UneClasse
+
+
+        public class UneClasseImbriquéePublique
+        {
+        }
+
+        private UneClasseImbriquéePublique mMembre3;
+        public UneClasseImbriquéePublique mMembre4;
+
+        public enum UnEnumImbriqué
+        {
+            Inconnu,
+            Connu
+        }
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            UneClasse uneClasse = new UneClasse();
+            var qqchse = uneClasse.mMembre4;
+
+            UneClasse.UnEnumImbriqué variable = UneClasse.UnEnumImbriqué.Connu;
+        }
+    }
+}

p03_POO/ex_014_002_typesImbriques/ex_014_002_typesImbriques.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_014_002_typesImbriques</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_014_002_typesImbriques</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_014_003_ClasseChampInitialiseurs/Program.cs

@@ -0,0 +1,70 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+namespace ex_014_003_ClasseChampInitialiseurs
+{
+    //la classe est le type de référence le plus commun
+    //avant class, on trouve un ou plusieurs modifiers : public, internal, abstract, sealed, static, unsafe, partial
+    // public rend cette classe visible et utilisable dans d'autres assemblages
+    // internal rend cette classe visible et utilisable dans l'assemblage uniquement
+    // les autres seront vus plus tard
+    internal class Disque
+    {
+        //un champ est une variable qui est un membre de cette classe
+        //pour respecter le principe d'encapsulation, un champ devrait toujours être privé (modifieur [accesseur] private par défaut) ou protégé (protected)
+        //mais un champ peut-être aussi public ou internal
+        string mTitre;
+
+        //un champ peut être initialisé dans sa déclaration (on parle d'initialiseur)
+        int mNombre = 1;
+
+        //un champ peut être de type valeur...
+        int année;
+
+        //... ou de type référence
+        Artiste mArtiste;
+
+        //si un champ a un modifier readonly, il ne peut être initialisé que dans sa déclaration (initialiseur) ou dans le constructeur ("run-time constant")
+        readonly string mMaisonDeDisque = "IUT";
+
+        //si un champ a un modifier const, il ne peut être initialisé que dans sa déclaration ("compile-time constant")
+        const string mTruc = "non rien";
+
+        //object initializers
+        //peuvent ainsi être initialisés sans constructeurs 
+        //attention : il ne vaut pas mieux mettre des membres en public. Cette méthode est donc surtout utile pour 
+        // des propriétés publiques (cf. plus tard)
+        public int A
+        {
+            get;
+            set;
+        }
+        public int B;
+        public int C;
+    }
+
+    class Artiste
+    {
+        //rien pour l'instant...
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Disque d = new Disque();
+
+            //initializers
+            Disque d2 = new Disque { A = 1, B = 2, C = 3 };
+            Disque d3 = new Disque() { A = 4, B = 5, C = 6 };
+        }
+    }
+}

p03_POO/ex_014_003_ClasseChampInitialiseurs/ex_014_003_ClasseChampInitialiseurs.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_014_003_ClasseChampInitialiseurs</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_014_003_ClasseChampInitialiseurs</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_014_004_constructeurs/Program.cs

@@ -0,0 +1,46 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+namespace ex_014_004_constructeurs
+{
+    internal class Disque
+    {
+        int mNombre = 1;
+
+        readonly string mMaisonDeDisque = "IUT";
+
+        //constructeurs 
+        //une classe peut avoir un ou plusieurs constructeurs, qui peuvent s'appeler à l'aide du mot clé this
+        //le constructeur sans paramètre est le constructeur par défaut
+        public Disque()
+        {
+        }
+        public Disque(string maison_de_disque)
+        {
+            mMaisonDeDisque = maison_de_disque;
+        }
+        public Disque(string maison_de_disque, int nombre)
+            : this(maison_de_disque)
+        {
+            mNombre = nombre;
+        }
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Disque d = new Disque();
+            Disque d2 = new Disque("Oh yes !");
+            Disque d3 = new Disque("Arf no !", 0);
+        }
+    }
+}

p03_POO/ex_014_004_constructeurs/ex_014_004_constructeurs.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_014_004_constructeurs</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_014_004_constructeurs</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_014_005_methodes/Program.cs

@@ -0,0 +1,58 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using static System.Console;
+
+namespace ex_014_005_methodes
+{
+    internal class Disque
+    {
+        //une méthode est définie juste après sa déclaration
+        //elle peut avoir aussi les modifieurs public, protected, private, internal
+        //elle peut être surchargée, tant que les paramètres sont différents (ref et out comptent)
+        public void Affiche()
+        {
+            WriteLine("Affiche()");
+        }
+        public void Affiche(int bof)
+        {
+            WriteLine("Affiche(int bof)");
+        }
+        public void Affiche(ref int bof)
+        {
+            WriteLine("Affiche(ref int bof)");
+        }
+
+        //constructeurs 
+        //une classe peut avoir un ou plusieurs constructeurs, qui peuvent s'appeler à l'aide du mot clé this
+        //le constructeur sans paramètre est le constructeur par défaut
+        public Disque()
+        {
+        }
+    }
+
+    class Artiste
+    {
+        //rien pour l'instant...
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            int a = 0;
+            Disque d = new Disque();
+            d.Affiche();
+            d.Affiche(a);
+            d.Affiche(ref a);
+        }
+    }
+}

p03_POO/ex_014_005_methodes/ex_014_005_methodes.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_014_005_methodes</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_014_005_methodes</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_014_006_object_ToString/Program.cs

@@ -0,0 +1,91 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using static System.Console;
+
+namespace ex_014_006_object_ToString
+{
+    //toutes les classes descendent de la classe Object. 
+    //Object contient un constructeur, et les méthodes : Equals, GetType, et ToString
+    //ici nous réécrivons ToString pour les classes Disque et Livre et Equals pour la classe Livre
+
+    class Disque
+    {
+        private string mArtiste;
+        string mTitre;
+        int mAnnéeCréation;
+
+        public Disque(string titre, int année, string artiste)
+        {
+            mTitre = titre;
+            mAnnéeCréation = année;
+            mArtiste = artiste;
+        }
+
+        //on réécrit ToString
+        public override string ToString()
+        {
+            return $"Le disque {mTitre} a été enregistré par {mArtiste} en {mAnnéeCréation}";
+        }
+    }
+
+    class Livre
+    {
+        protected string mTitre;
+        int mAnnéeSortie;
+        string mAuteur;
+
+        public Livre(string titre, int année, string auteur)
+        {
+            mTitre = titre;
+            mAnnéeSortie = année;
+            mAuteur = auteur;
+        }
+
+        //on réécrit ToString
+        public override string ToString()
+        {
+            return $"Le livre {mTitre} a été écrit par {mAuteur} en {mAnnéeSortie}";
+        }
+
+        //on réécrit Equals, ici on décide par exemple que l'année n'a pas d'importance (une nouvelle édition par exemple)
+        public override bool Equals(object obj)
+        {
+            if (mTitre == ((Livre)obj).mTitre && mAuteur == ((Livre)obj).mAuteur)
+                return true;
+            return false;
+        }
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            Livre l = new Livre("Attenti al Gorilla", 1995, "Sandrone Dazieri");
+            Disque d = new Disque("Underground", 2007, "Chris Potter");
+
+            Write($"{l.GetType().Name} : ");
+            WriteLine(l);
+
+            Write($"{d.GetType().Name} : ");
+            WriteLine(d);
+
+            Livre l2 = new Livre("Attenti al Gorilla", 1997, "Sandrone Dazieri");
+            Livre l3 = new Livre("Attenti", 1995, "Sandrone Dazieri");
+            if (l2.Equals(l))
+                WriteLine("l2 = l");
+            if (l3.Equals(l))
+                WriteLine("l3 = l");
+        }
+    }
+}

p03_POO/ex_014_006_object_ToString/ex_014_006_object_ToString.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_014_006_object_ToString</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_014_006_object_ToString</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_014_007_expression_bodied_methods/Program.cs

@@ -0,0 +1,93 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using static System.Console;
+
+namespace ex_014_007_expression_bodied_methods
+{
+    class Rectangle
+    {
+        float mLargeur;
+        float mLongueur;
+
+        public Rectangle(float largeur, float longueur)
+        {
+            mLargeur = largeur;
+            mLongueur = longueur;
+        }
+
+        /// <summary>
+        /// une méthode simple ne renvoyant rien (void) et prenant un paramètre
+        /// </summary>
+        /// <param name="largeur">nouvelle largeur</param>
+        public void ChangeLargeur(float largeur)
+        {
+            mLargeur = largeur;
+        }
+
+        /// <summary>
+        /// une méthode très similaire à la précédente (ne rendant rien et prenant un paramètre) mais écrite avec une expression 
+        /// Notez la flèche => 
+        /// Marche bien pour les méthodes avec une seule instruction
+        /// </summary>
+        /// <param name="longueur">nouvelle longueur</param>
+        public void ChangeLongeur(float longueur) => mLongueur = longueur;
+
+        /// <summary>
+        /// méthode simple ne prenant rien et rendant un float
+        /// </summary>
+        /// <returns>l'aire de ce Rectangle</returns>
+        public float CalculeAire()
+        {
+            return mLargeur * mLongueur;
+        }
+
+        /// <summary>
+        /// une méthode très similaire à la précédente (ne prenant rien et rendant un float) mais écrite avec une expression
+        /// Notez la flèche =>
+        /// Notez l'absence du mot-clef return
+        /// Marche bien pour les méthodes avec une seule instruction
+        /// </summary>
+        /// <returns>le périmètre de ce Rectangle</returns>
+        public float CalculePérimètre() => 2 * (mLargeur + mLongueur);
+    }
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            Rectangle r = new Rectangle(2, 3);
+            WriteLine("Rectangle r = new Rectangle(2, 3);");
+            WriteLine($"r.CalculeAire() : {r.CalculeAire()} u²");
+            WriteLine($"r.CalculePérimètre() : {r.CalculePérimètre()} u");
+            r.ChangeLargeur(3);
+            r.ChangeLongeur(4);
+            WriteLine("r.ChangeLargeur(3);");
+            WriteLine("r.ChangeLongeur(4);");
+            WriteLine($"r.CalculeAire() : {r.CalculeAire()} u²");
+            WriteLine($"r.CalculePérimètre() : {r.CalculePérimètre()} u");
+
+            WriteLine();
+            WriteLine("où CalculeAire() est écrite classiquement :");
+            WriteLine("public float CalculeAire() { return mLargeur * mLongueur; }");
+            WriteLine();
+            WriteLine("et CalculePérimètre() est écrite avec une expression :");
+            WriteLine("public float CalculePérimètre() => 2*(mLargeur+mLongueur);");
+            WriteLine();
+            WriteLine("ChangeLargeur() est écrite classiquement :");
+            WriteLine("public void ChangeLargeur(float largeur) { mLargeur = largeur; }");
+            WriteLine();
+            WriteLine("et ChangeLongeur() est écrite avec une expression :");
+            WriteLine("public void ChangeLongeur(float longueur) => mLongueur = longueur;");
+        }
+    }
+}

p03_POO/ex_014_007_expression_bodied_methods/ex_014_007_expression_bodied_methods.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_014_007_expression_bodied_methods</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_014_007_expression_bodied_methods</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_014_008_deconstruction/Program.cs

@@ -0,0 +1,66 @@
+// ========================================================================
+//
+// Copyright (C) 2017-2018 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2017-09-28
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_014_008_deconstruction
+{
+    /// <summary>
+    /// NOUVEAUTE C# 7.0
+    /// 
+    /// Comme les Tuples (cf. ex_004_009), n'importe quel type peut-être déconstruit, à l'aide d'une méthode de déconstruction
+    /// Dans la classe Nounours ci-dessous, la méthode Decontruct possède des variables en paramètres de sortie out permettant de déconstruire une instance de Nounours.
+    /// Le Main ci-dessous l'utilise.
+    /// </summary>
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Console.OutputEncoding = System.Text.Encoding.UTF8;
+
+            //construction
+            Nounours monNounours = new Nounours("Chucky", 4, new DateTime(1988, 11, 9));
+
+            //déconstruction
+            monNounours.Deconstruct(out string leNom, out int leNbPoils, out DateTime laDateDeNaissance);
+
+            WriteLine($"{leNom} a {leNbPoils} poils et est né en {laDateDeNaissance.Year}");
+
+            //on peut également ignorer certaines variables avec _ (discard)
+            monNounours.Deconstruct(out string leNom2, out _, out DateTime laDateDeNaissance2);
+            WriteLine($"{leNom2} est né en {laDateDeNaissance2.Year}");
+        }
+    }
+
+    class Nounours
+    {
+        private string nom;
+
+        private int nbPoils;
+
+        private DateTime naissance;
+
+        public Nounours(string _nom, int _nbPoils, DateTime _naissance)
+        {
+            nom = _nom;
+            nbPoils = _nbPoils;
+            naissance = _naissance;
+        }
+
+        public void Deconstruct(out string outNom, out int outNbPoils, out DateTime outNaissance)
+        {
+            outNom = nom;
+            outNbPoils = nbPoils;
+            outNaissance = naissance;
+        }
+    }
+}

p03_POO/ex_014_008_deconstruction/ex_014_008_deconstruction.csproj

@@ -0,0 +1,6 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+  </PropertyGroup>
+</Project>

p03_POO/ex_015_001_static/Program.cs

@@ -0,0 +1,114 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_015_001_static
+{
+    public class Etudiant
+    {
+        Random random = new Random();
+
+        public int GenereNoteAvecRandomNonStatic()
+        {
+            return random.Next(0, 21);
+        }
+
+        static Random randomStatic;
+
+        public int GenereNoteAvecRandomStatic()
+        {
+            return randomStatic.Next(0, 21);
+        }
+
+        //un constructeur static est nécessairement privé et ne peut pas être appelé directement
+        //il sera appelé lors de la première construction d'un objet de ce type
+        static Etudiant()
+        {
+            randomStatic = new Random();
+            //ici, il est évidemment préférable d'utiliser l'initialiseur plutôt que le constructeur pour Random
+            //mais c'est juste pour l'exemple d'un constructeur static
+        }
+
+        //membre non statique
+        public string Année = "2013-2014";
+
+        //méthode non statique
+        public string GetAnnéeFormation()
+        {
+            //une méthode non statique peut utiliser aussi bien des membres non statiques que des membres statiques
+            return $"{Formation} ({Année})";
+        }
+
+        //membre statique (partagé par toutes les instances de cette classe)
+        public static string Formation = "DUT Informatique";
+
+        //méthode statique
+        public static string GetFormation()
+        {
+            //une méthode statique ne peut pas utiliser de membres non statiques 
+            //return string.Format("{0} ({1})", Formation, Année);
+
+            //une méthode statique ne peut utiliser que des membres statiques
+            return $"{Formation} ({Université})";
+        }
+
+        //un membre const est toujours statique, même si on ne le précise pas dans la syntaxe
+        public const string Université = "Université d'Auvergne";
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            Etudiant[] tableauEtudiants = new Etudiant[10];
+            for (int i = 0; i < tableauEtudiants.Length; i++)
+            {
+                tableauEtudiants[i] = new Etudiant();
+            }
+
+            WriteLine("Méthode avec random non static");
+            for (int i = 0; i < tableauEtudiants.Length; i++)
+            {
+                WriteLine($"L'étudiant {i} a obtenu la note de {tableauEtudiants[i].GenereNoteAvecRandomNonStatic()}/20");
+            }
+            WriteLine();
+
+            WriteLine("Méthode avec random static");
+            for (int i = 0; i < tableauEtudiants.Length; i++)
+            {
+                WriteLine($"L'étudiant {i} a obtenu la note de {tableauEtudiants[i].GenereNoteAvecRandomStatic()}/20");
+            }
+            WriteLine();
+
+            WriteLine("Année");
+            //pour appeler les membres non statiques et les méthodes non statiques,
+            //une instance est obligatoire
+            Etudiant étudiant = new Etudiant();
+            WriteLine(étudiant.Année);
+            WriteLine(étudiant.GetAnnéeFormation());
+            WriteLine();
+
+            WriteLine("Formation");
+            //pour appeler les membres statiques et les méthodes statiques,
+            //on utiliser les méthodes sur le type lui-même, sans instances
+            WriteLine(Etudiant.Formation);
+            WriteLine(Etudiant.GetFormation());
+            WriteLine();
+
+            WriteLine("Autre exemple de propriété statique : DateTime.Now");
+            WriteLine($"DateTime.Now = {DateTime.Now}");
+        }
+    }
+}

p03_POO/ex_015_001_static/ex_015_001_static.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_015_001_static</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_015_001_static</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_015_002_ordreAppelStatic/Program.cs

@@ -0,0 +1,58 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using static System.Console;
+
+namespace ex_015_002_ordreAppelStatic
+{
+    class SansIntérêt
+    {
+        static int n = 0;
+
+        public SansIntérêt(string nom)
+        {
+            n++;
+            WriteLine($"exécution du constructeur de l'instance sans intérêt n°{n}({nom})");
+        }
+    }
+
+    class UneClasse
+    {
+        public static SansIntérêt mMembreStatique1 = new SansIntérêt("membre statique 1");
+        public static SansIntérêt mMembreStatique2 = new SansIntérêt("membre statique 2");
+        static UneClasse()
+        {
+            WriteLine("exécution du constructeur par défaut statique de UneClasse");
+        }
+        public SansIntérêt mMembreNonStatique1 = new SansIntérêt("membre instance 1");
+
+        public SansIntérêt mMembreNonStatique2 = new SansIntérêt("membre instance 2");
+
+
+
+        public UneClasse()
+        {
+            WriteLine("exécution du constructeur de l'instance de UneClasse");
+        }
+
+
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            UneClasse c = new UneClasse();
+        }
+    }
+}

p03_POO/ex_015_002_ordreAppelStatic/ex_015_002_ordreAppelStatic.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_015_002_ordreAppelStatic</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_015_002_ordreAppelStatic</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_015_003_singleton/Program.cs

@@ -0,0 +1,47 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using static System.Console;
+
+namespace ex_015_003_singleton
+{
+    //le patron de conception Singleton permet de restreindre le nombre d'instances à 1
+    public class IutClermont
+    {
+        //le constructeur est privé et ne peut pas être appelé en dehors de la classe
+        private IutClermont()
+        {
+            Description = "Meilleur IUT d'Informatique de France";
+        }
+
+        //membre non statique, utilisable par les instances
+        public string Description;
+
+        //la classe possède un membre statique du type de la classe qui lui, peut appeler le constructeur privé pour se construire
+        static IutClermont mInstance = new IutClermont();
+
+        //méthode statique de la classe, rendant l'instance statique de cette classe
+        public static IutClermont GetInstance()
+        {
+            return mInstance;
+        }
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            //IutClermont iut = new IutClermont(); //interdit
+            IutClermont iut = IutClermont.GetInstance();
+            WriteLine(iut.Description);
+        }
+    }
+}

p03_POO/ex_015_003_singleton/ex_015_003_singleton.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_015_003_singleton</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_015_003_singleton</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_015_004_using_static/Program.cs

@@ -0,0 +1,126 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-23
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+using static ex_015_004_using_static.Etudiant;
+using static ex_015_004_using_static.BacOrigine;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ex_015_004_using_static
+{
+    public class Etudiant
+    {
+        Random random = new Random();
+
+        public int GenereNoteAvecRandomNonStatic()
+        {
+            return random.Next(0, 21);
+        }
+
+        static Random randomStatic;
+
+        public int GenereNoteAvecRandomStatic()
+        {
+            return randomStatic.Next(0, 21);
+        }
+
+        //un constructeur static est nécessairement privé et ne peut pas être appelé directement
+        //il sera appelé lors de la première construction d'un objet de ce type
+        static Etudiant()
+        {
+            randomStatic = new Random();
+            //ici, il est évidemment préférable d'utiliser l'initialiseur plutôt que le constructeur pour Random
+            //mais c'est juste pour l'exemple d'un constructeur static
+        }
+
+        //membre non statique
+        public string Année = "2013-2014";
+
+        //méthode non statique
+        public string GetAnnéeFormation()
+        {
+            //une méthode non statique peut utiliser aussi bien des membres non statiques que des membres statiques
+            return $"{Formation} ({Année})";
+        }
+
+        //membre statique (partagé par toutes les instances de cette classe)
+        public static string Formation = "DUT Informatique";
+
+        //méthode statique
+        public static string GetFormation()
+        {
+            //une méthode statique ne peut pas utiliser de membres non statiques 
+            //return string.Format("{0} ({1})", Formation, Année);
+
+            //une méthode statique ne peut utiliser que des membres statiques
+            return $"{Formation} ({Université})";
+        }
+
+        //un membre const est toujours statique, même si on ne le précise pas dans la syntaxe
+        public const string Université = "Université d'Auvergne";
+
+        public BacOrigine Origine;
+    }
+
+    public enum BacOrigine
+    {
+        Inconnu,
+        S,
+        ES,
+        L,
+        STI2D
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            WriteLine("sans : using static ex_015_004_using_static.Etudiant;    il faudrait écrire :");
+            WriteLine($"Etudiant.Formation : {Etudiant.Formation}");
+            WriteLine($"Etudiant.Université : {Etudiant.Université}");
+            WriteLine($"Etudiant.GetFormation() : {Etudiant.GetFormation()}");
+            WriteLine();
+            WriteLine("grâce à : using static ex_015_004_using_static.Etudiant;    on peut simplement écrire :");
+            WriteLine($"Formation : {Formation}");
+            WriteLine($"Université : {Université}");
+            WriteLine($"GetFormation() : {GetFormation()}");
+            WriteLine();
+            WriteLine("C'est d'ailleurs la même chose pour l'utilisation de la Console :");
+            WriteLine("sans :  using static System.Console;     il faudrait écrire :");
+            string prout = "prout";
+            WriteLine($"Console.WriteLine(\"prout\");");
+            Console.WriteLine(prout);
+            WriteLine();
+            WriteLine("grâce à : using static System.Console;    on peut écrire :");
+            WriteLine($"WriteLine(\"prout\");");
+            WriteLine(prout);
+            WriteLine();
+            WriteLine("Marche également avec les enum");
+            WriteLine("sans : using static ex_015_004_using_static.BacOrigine;     il faudrait écrire");
+            WriteLine("e.Origine = BacOrigine.STI2D;");
+            Etudiant e = new Etudiant();
+            e.Origine = BacOrigine.STI2D;
+            WriteLine();
+            WriteLine("grâce à : using static ex_015_004_using_static.BacOrigine;     on peut écrire");
+            WriteLine("e.Origine = STI2D;");
+            e.Origine = STI2D;
+            WriteLine();
+            WriteLine("Tout cela marche très bien, tant que le compilateur ne détecte aucune ambiguité");
+
+        }
+    }
+}

p03_POO/ex_015_004_using_static/ex_015_004_using_static.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_015_004_using_static</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_015_004_using_static</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_016_001_getters_setters_methods/Program.cs

@@ -0,0 +1,117 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-24
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_016_001_getters_setters_methods
+{
+    class Nounours
+    {
+        //un getter permet de lire un champ privé
+        public string GetNom()
+        {
+            return mNom;
+        }
+
+        //un setter permet de modifier un champ privé
+        public void SetNom(string value)
+        {
+            mNom = value;
+        }
+        private string mNom;
+
+        //on peut ainsi, protéger nos champs privés de différentes manières
+        public int GetTaille()
+        {
+            return mTaille;
+        }
+        public void SetTaille(int value)
+        {
+            if (value > 0)
+            {
+                mTaille = value;
+            }
+        }
+        private int mTaille;
+
+        public int GetPoils()
+        {
+            return mPoils;
+        }
+        private void SetPoils(int value)
+        {
+            if (value >= 0)
+            {
+                mPoils = value;
+            }
+        }
+        private int mPoils;
+
+        //on peut aussi avoir un getter uniquement et transformer ainsi le champ en lecture seule
+        //ou un setter privé comme pour mPoils
+        public DateTime GetDateDeNaissance()
+        {
+            return mDateDeNaissance;
+        }
+        private DateTime mDateDeNaissance;
+
+        //ou en écriture seule...
+
+        //un getter n'est pas forcément lié à un membre, mais peut simuler la lecture d'un membre qui est alors calculé à la volée
+        public float GetPoilsParCm()
+        {
+            return (float)mPoils / (float)mTaille;
+        }
+
+        //on utilise les setters pour initialiser les membres
+        public Nounours(string nom, int taille, DateTime naissance, int poils)
+        {
+            SetNom(nom);
+            SetTaille(taille);
+            mDateDeNaissance = naissance;
+            SetPoils(poils);
+        }
+
+        //getter et setter statiques
+        public static string GetDéfinition()
+        {
+            return mDéfinition;
+        }
+        public static void SetDéfinition(string value)
+        {
+            mDéfinition = value;
+        }
+        private static string mDéfinition = "Mot enfantin pour désigner un ours en peluche";
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+    
+            //utilisation des getters et setters
+            Nounours nounours = new Nounours("ours", 42, DateTime.Today, 30000);
+            WriteLine("Nounours nounours = new Nounours(\"ours\", 42, DateTime.Today, 30000);");
+            WriteLine($"Nom : {nounours.GetNom()}");
+            WriteLine($"Poils : {nounours.GetPoils()}");
+            WriteLine($"Taille : {nounours.GetTaille()}");
+            WriteLine($"Date de naissance : {nounours.GetDateDeNaissance()}");
+            WriteLine($"Poils par cm : {nounours.GetPoilsParCm()}");
+            WriteLine("nounours.SetTaille(41);");
+            nounours.SetTaille(41);
+            WriteLine($"Taille : {nounours.GetTaille()}");
+            WriteLine($"Poils par cm : {nounours.GetPoilsParCm()}");
+            WriteLine($"Définition : {Nounours.GetDéfinition()}");
+        }
+    }
+}

p03_POO/ex_016_001_getters_setters_methods/ex_016_001_getters_setters_methods.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_016.0.6_getters_setters_methods</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_016.0.6_getters_setters_methods</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_016_002_properties/Program.cs

@@ -0,0 +1,141 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-25
+//
+// ========================================================================
+
+using System;
+using static System.Console;
+
+namespace ex_016_002_properties
+{
+    class Nounours
+    {
+        //une propriété ressemble à un champ de l'extérieur mais se comporte comme une méthode à l'intérieur
+        //on l'utilise comme accesseur sur un champ privé pour garantir l'encapsulation
+        //en lecture/écriture, lecture ou écriture
+        //on l'associe donc généralement à un champ privé
+        public string Nom
+        {
+            get //public string GetNom()
+            {
+                return mNom;
+            }
+            set //public void SetNom(string value)
+            {
+                mNom = value;
+            }
+        }
+        private string mNom;
+
+        //on peut en conséquence, protéger nos champs privés de différentes manières
+        public int Taille
+        {
+            get
+            {
+                return mTaille;
+            }
+            set
+            {
+                if (value > 0)
+                {
+                    mTaille = value;
+                }
+            }
+        }
+        private int mTaille = 100;
+
+        //on peut aussi avoir une propriété en lecture seule
+        public DateTime DateDeNaissance
+        {
+            get
+            {
+                return mDateDeNaissance;
+            }
+        }
+        private DateTime mDateDeNaissance;
+
+        //ou en écriture seule
+
+        //automatic properties
+        //on peut aussi définir une propriété sans membre privé si le getter et le setter sont basiques (aux modifiers près)
+        //(ne marche pas sur les structures)
+        public int Poils
+        {
+            get;
+            private set;
+        }
+
+        //calculated properties
+        //une propriété n'est pas forcément liée à un membre privé (ou protégé), elle est peut être calculée à partir d'autres membres ou propriétés
+        public float PoilsParCm
+        {
+            get
+            {
+                return (float)Poils / Taille;
+            }
+        }
+
+        //expression-bodied read-only properties (C#6)
+        // une propriété calculée ou read-only peut aussi être déclarée directement à l'aide d'une expression
+        // notez qu'il n'est plus nécessaire d'utiliser les { }, le mot-clef get, et le mot-clef return
+        public int Age => DiffYears + (DateDeNaissance.AddYears(DiffYears) > DateTime.Today ? -1 : 0);
+        //et une petite propriété privée rapide pour simplifier l'écriture de la propriété précédente
+        private int DiffYears => DateTime.Today.Year - DateDeNaissance.Year;
+
+        // depuis C#6 on peut également initialiser une propriété automatique juste après l'avoir écrite.
+        // C'est notamment très pratique pour les propriétés automatiques en lecture seule.
+        public string Odeur { get; set; } = "chien mouillé";
+
+        public Nounours(string nom, int taille, DateTime naissance, int poils)
+        {
+            Nom = nom;
+            Taille = taille;
+            mDateDeNaissance = naissance;
+            Poils = poils;
+        }
+
+        //propriété statique
+        public static string Définition
+        {
+            get
+            {
+                return mDéfinition;
+            }
+            set
+            {
+                mDéfinition = value;
+            }
+        }
+        private static string mDéfinition = "Mot enfantin pour désigner un ours en peluche";
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+         
+            //les propriétés s'utilisent comme des membres
+            Nounours nounours = new Nounours("ours", 42, new DateTime(2015, 9, 26), 30000);
+            WriteLine("Nounours nounours = new Nounours(\"ours\", 42, DateTime.Today, 30000);");
+            WriteLine($"Nom : {nounours.Nom}");
+            WriteLine($"Poils : {nounours.Poils}");
+            WriteLine($"Taille : {nounours.Taille}");
+            WriteLine($"Age : {nounours.Age}");
+            WriteLine($"Odeur : {nounours.Odeur}");
+            WriteLine($"Date de naissance : {nounours.DateDeNaissance}");
+            WriteLine($"Poils par cm : {nounours.PoilsParCm}");
+            WriteLine("nounours.Taille = 41;");
+            nounours.Taille = 41;
+            WriteLine($"Taille : {nounours.Taille}");
+            WriteLine($"Poils par cm : {nounours.PoilsParCm}");
+            WriteLine($"Définition : {Nounours.Définition}");
+        }
+    }
+}

p03_POO/ex_016_002_properties/ex_016_002_properties.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_016_002_properties</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_016_002_properties</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_016_003_indexers/Program.cs

@@ -0,0 +1,232 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-26
+//
+// ========================================================================
+
+using static System.Console;
+
+namespace ex_016_003_indexers
+{
+    class Nounours
+    {
+        //une propriété
+        public string Nom
+        {
+            get
+            {
+                return mNom;
+            }
+            set
+            {
+                mNom = value;
+            }
+        }
+        private string mNom;
+    }
+
+    //classe possédant des indexeurs
+    class MonLit
+    {
+        Nounours[] mNounours;
+
+        //constructeur
+        public MonLit(int nombre)
+        {
+            mNounours = new Nounours[nombre];
+        }
+
+        //une propriété de plus
+        public int NombreNounours
+        {
+            get
+            {
+                return mNounours.Length;
+            }
+        }
+
+        /// <summary>
+        /// indexeur permettant de récupérer ou d'écrire le (index)ième nounours dans le tableau mNounours
+        /// </summary>
+        /// <param name="index">index du nounours à récupérer ou écrire</param>
+        /// <returns>rend le (index)ième nounours ou null si l'index n'est pas valide</returns>
+        public Nounours this[int index]
+        {
+            get
+            {
+                if (index >= NombreNounours || index < 0)
+                {
+                    return null;
+                }
+                return mNounours[index];
+            }
+            set
+            {
+                if (index < NombreNounours && index >= 0)
+                {
+                    mNounours[index] = value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// indexeur en lecture seule permettant de récupérer un nounours dans le tableau mNounours à partir de son nom
+        /// </summary>
+        /// <param name="nom">nom du Nounours recherché</param>
+        /// <returns>le nounours avec ce nom, ou null si le nom n'est pas reconnu</returns>
+        public Nounours this[string nom]
+        {
+            get
+            {
+                foreach (Nounours n in mNounours)
+                {
+                    if (n.Nom == nom)
+                    {
+                        return n;
+                    }
+                }
+                return null;
+            }
+        }
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            WriteLine("Création d'un lit avec trois nounours");
+            MonLit monlit = new MonLit(3);
+
+            //utilisation de l'indexeur this[int] en écriture (set)
+            monlit[0] = new Nounours { Nom = "zinzin" };
+            monlit[1] = new Nounours { Nom = "rooooo" };
+            monlit[2] = new Nounours { Nom = "argh" };
+
+            WriteLine("contenu du 1er lit");
+            for (int i = 0; i < monlit.NombreNounours; i++)
+            {
+                //utilisation de l'indexeur this[int] en lecture (get)
+                WriteLine(monlit[i].Nom);
+            }
+
+            ReadLine();
+
+            WriteLine("modification d'un nounours du lit avec l'indexeur");
+
+            //utilisation de l'idexeur this[string]
+            if (monlit["rooooo"] != null)
+            {
+                //utilisation de l'idexeur this[string]
+                monlit["rooooo"].Nom = "zibaouin";
+            }
+
+            WriteLine("contenu du lit");
+            for (int i = 0; i < monlit.NombreNounours; i++)
+            {
+                //utilisation de l'idexeur this[int] en lecture
+                WriteLine(monlit[i].Nom);
+            }
+
+            ReadLine();
+            WriteLine("création d'une maison avec deux lits : 1er lit = le précédent, 2ème lit de 4 nouveaux nounours");
+            MaMaison maison = new MaMaison(2);
+            //utilisation de l'indexeur simple de MaMaison this[int]
+            maison[0] = monlit;
+            maison[1] = new MonLit(4);
+            //notez que maison[1, 0] = new Nounours(); ne compile pas, car l'indexeur n'a pas de 'set'
+            //mais on peut accéder quand même à maison[1][0] car on accède à la référence maison[1] de type MonLit et de là, grâce à l'indexeur,
+            //au nounours maison[1][0]... donc ... ATTENTION AUX REFERENCES PUBLIQUES DANS VOTRE API !
+
+            //utilisation de l'indexeur this[int] de MaMaison puis de l'indexeur this[int] de MonLit
+            maison[1][0] = new Nounours();
+            //utilisation de l'indexeur double this[int, int] de MaMaison
+            maison[1, 0].Nom = "Nigel";
+            maison[1][1] = new Nounours();
+            maison[1, 1].Nom = "David";
+            maison[1][2] = new Nounours();
+            maison[1, 2].Nom = "Derek";
+            maison[1][3] = new Nounours();
+            maison[1, 3].Nom = "Ian";
+            WriteLine("contenu du lit");
+            for (int i = 0; i < maison.NbreLits; i++)
+            {
+                WriteLine($"lit n°{(i + 1)}");
+                for (int j = 0; j < maison[i].NombreNounours; j++)
+                {
+                    WriteLine(maison[i, j].Nom);
+                }
+                WriteLine();
+            }
+        }
+    }
+
+    //exemple d'indexeur à 2 variables
+    class MaMaison
+    {
+        MonLit[] mLits;
+
+        public MaMaison(int nombre)
+        {
+            mLits = new MonLit[nombre];
+        }
+
+        //une propriété en lecture seule
+        public int NbreLits
+        {
+            get
+            {
+                return mLits.Length;
+            }
+        }
+
+
+        /// <summary>
+        /// un indexeur simple 
+        /// </summary>
+        /// <param name="lit">indice du lit à atteindre dans le tableau mLits</param>
+        /// <returns></returns>
+        public MonLit this[int lit]
+        {
+            get
+            {
+                if (lit >= NbreLits || lit < 0)
+                {
+                    return null;
+                }
+                return mLits[lit];
+            }
+            set
+            {
+                if (lit < NbreLits && lit >= 0)
+                {
+                    mLits[lit] = value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// un indexeur à double entrée
+        /// </summary>
+        /// <param name="lit">indice du lit à atteindre dans le tableau mLits</param>
+        /// <param name="nounours">indice du nounours à atteindre dans le tableau mNounours de mLits[lit]</param>
+        /// <returns></returns>
+        public Nounours this[int lit, int nounours]
+        {
+            get
+            {
+                if (lit >= NbreLits || lit < 0 || nounours >= mLits[lit].NombreNounours || nounours < 0)
+                {
+                    return null;
+                }
+                return mLits[lit][nounours];
+            }
+        }
+    }
+}

p03_POO/ex_016_003_indexers/ex_016_003_indexers.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_016_003_indexers</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_016_003_indexers</PackageId>
+    <RuntimeFrameworkVersion>6.0.6</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_016_004_readonly/Program.cs

@@ -0,0 +1,69 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : Program.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-26
+//
+// ========================================================================
+
+using static System.Console;
+
+namespace ex_016_004_readonly
+{
+    /// <summary>
+    /// classe représentant un disque
+    /// </summary>
+    class Disque
+    {
+        /// <summary>
+        /// artiste du disque (en readonly) (public pour la simplicité de l'exemple !)
+        /// </summary>
+        public readonly Artiste mArtiste;
+
+        /// <summary>
+        /// année de sortie (en readonly) (public pour la simplicité de l'exemple !)
+        /// </summary>
+        public readonly int mAnnée;
+
+        /// <summary>
+        /// constructeur
+        /// </summary>
+        /// <param name="artiste"></param>
+        /// <param name="année"></param>
+        public Disque(Artiste artiste, int année)
+        {
+            mArtiste = artiste;
+            mAnnée = année;
+        }
+    }
+
+    /// <summary>
+    /// classe représentant un artiste
+    /// </summary>
+    class Artiste
+    {
+        /// <summary>
+        /// nom de l'artiste (public pour la simplicité de l'exemple !)
+        /// </summary>
+        public string mName;
+    }
+
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            OutputEncoding = System.Text.Encoding.UTF8;
+
+            Disque d = new Disque(new Artiste { mName = "Miles Davis" }, 1956);
+            WriteLine($"artiste : {d.mArtiste.mName}; année : {d.mAnnée}");
+            //d.mAnnée = 1951; // ne compile pas (pas d'assignation possible car readonly)
+            //d.mArtiste = new Artiste { mName = "Charlie Parker" };// ne compile pas (pas d'assignation possible car readonly)
+            d.mArtiste.mName = "Charlie Parker"; //compile par l'adresse mArtiste n'a pas changé (readonly), mais le contenu pointé par la référence
+            // n'est pas en readonly et peut donc être modifié
+            WriteLine($"artiste : {d.mArtiste.mName}; année : {d.mAnnée}");
+        }
+    }
+}

p03_POO/ex_016_004_readonly/ex_016_004_readonly.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <AssemblyName>ex_016_004_readonly</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <PackageId>ex_016_004_readonly</PackageId>
+    <RuntimeFrameworkVersion>5.0.0</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+  </PropertyGroup>
+</Project>

p03_POO/ex_016_005_partial/MaClasse.QqsDétails.cs

@@ -0,0 +1,23 @@
+// ========================================================================
+//
+// Copyright (C) 2016-2017 MARC CHEVALDONNE
+//                         marc.chevaldonne.free.fr
+//
+// Module        : MaClasse.QqsDétails.cs
+// Author        : Marc Chevaldonné
+// Creation date : 2016-09-26
+//
+// ========================================================================
+
+namespace ex_016_005_partial
+{
+    partial class MaClasse
+    {
+        public int N3
+        {
+            get;
+            set;
+        }
+
+    }
+}