mise à jour de la documentation

Sources/ConsoleApp/Evenements.cs

@@ -1,154 +1,172 @@
-using CoreLibrary.Events;
+using CoreLibrary.Events;
-using CoreLibrary;
+using CoreLibrary;
-
+
-namespace ConsoleApp
+namespace ConsoleApp
-{
+{
-    /// <summary>
+    /// <summary>
-    /// Fournit des gestionnaires d'événements pour les événements liés au déroulement de la partie.
+    /// Fournit un ensemble de méthodes écoutant les événements liés au déroulement de la partie.
-    /// </summary>
+    /// </summary>
-    public static class Evenements
+    public static class Evenements
-    {
+    {
-        /// <summary>
+        /// <summary>
-        /// Gestionnaire d'événement pour l'ajout d'un joueur.
+        /// Ecoute l'événement en rapport avec la demande du nom d'un joueur.
-        /// </summary>
+        /// <param name="sender">La classe qui appelle l'événement; ici Partie.</param>
-        public static string? DemanderJoueur(Object? sender, DemanderJoueurEventArgs e)
+        /// <param name="e">L'instance de l'événement DemanderJoueurEventArgs créée par Partie.</param>
-        {
+        /// <returns>Le nom du joueur.</returns>
-            Console.WriteLine($"Joueur {e.Numero}");
+        /// </summary>
-            Console.Write(">>> ");
+        public static string? DemanderJoueur(Object? sender, DemanderJoueurEventArgs e)
-
+        {
-            string? nom = Console.ReadLine();
+            Console.WriteLine($"Joueur {e.Numero}");
-
+            Console.Write(">>> ");
-            Console.WriteLine();
+
-
+            string? nom = Console.ReadLine();
-            return nom;
+
-        }
+            Console.WriteLine();
-
+
-
+            return nom;
-        /// <summary>
+        }
-        /// Gestionnaire d'événement pour le début de la partie.
+
-        /// </summary>
+
-        public static void CommencerLaPartie(Object? sender, DebutPartieEventArgs e)
+        /// <summary>
-        {
+        /// Ecoute l'événement en rapport avec le début de la partie.
-            Utils.DessinerSeparateur();
+        /// <param name="sender">La classe qui appelle l'événement; ici Partie.</param>
-
+        /// <param name="e">L'instance de l'événement DebutPartieEventArgs créée par Partie.</param>
-            Console.WriteLine("La partie commence, bonne chance à tous !\n");
+        /// </summary>
-        }
+        public static void CommencerLaPartie(Object? sender, DebutPartieEventArgs e)
-
+        {
-        /// <summary>
+            Utils.DessinerSeparateur();
-        /// Gestionnaire d'événement pour le début d'un nouveau tour.
+
-        /// </summary>
+            Console.WriteLine("La partie commence, bonne chance à tous !\n");
-        public static void NouveauTour(Object? sender, NouveauTourEventArgs e)
+        }
-        {
+
-            Utils.DessinerSeparateur();
+        /// <summary>
-
+        /// Ecoute l'événement en rapport avec un nouveau tour.
-            Console.WriteLine($"Tour {e.Tour} - {e.Joueur.Nom}\n");
+        /// <param name="sender">La classe qui appelle l'événement; ici Partie.</param>
-
+        /// <param name="e">L'instance de l'événement NouveauTourEventArgs créée par Partie.</param>
-            Utils.DessinerPlateau(e.Grille, e.Indicateurs);
+        /// </summary>
-
+        public static void NouveauTour(Object? sender, NouveauTourEventArgs e)
-            Console.WriteLine();
+        {
-
+            Utils.DessinerSeparateur();
-        }
+
-
+            Console.WriteLine($"Tour {e.Tour} - {e.Joueur.Nom}\n");
-        /// <summary>
+
-        /// Gestionnaire d'événement pour la demande d'ajout d'un jeton.
+            Utils.DessinerPlateau(e.Grille, e.Indicateurs);
-        /// </summary>
+
-        public static Jeton? DemanderJeton(Object? sender, DemanderJetonEventArgs e)
+            Console.WriteLine();
-        {
+
-            Console.TreatControlCAsInput = true;
+        }
-            Console.CursorVisible = false;
+
-
+        /// <summary>
-            bool aChoisi = false;
+        /// Ecoute l'événement en rapport avec la demande d'un jeton.
-            int indice = 0;
+        /// <param name="sender">La classe qui appelle l'événement; ici Partie.</param>
-            Couleur[] couleurs = (Couleur[])Enum.GetValues(typeof(Couleur));
+        /// <param name="e">L'instance de l'événement DemanderJetonEventArgs créée par Partie.</param>
-
+        /// <returns>Le jeton choisi par le joueur.</returns>
-            while (!aChoisi)
+        /// </summary>
-            {
+        public static Jeton? DemanderJeton(Object? sender, DemanderJetonEventArgs e)
-                Utils.DessinerPion(couleurs[indice]);
+        {
-                Console.Write("\b\b\b");
+            Console.TreatControlCAsInput = true;
-
+            Console.CursorVisible = false;
-                switch (Console.ReadKey(true).Key)
+
-                {
+            bool aChoisi = false;
-                    case ConsoleKey.Enter:
+            int indice = 0;
-                        aChoisi = true;
+            Couleur[] couleurs = (Couleur[])Enum.GetValues(typeof(Couleur));
-                        break;
+
-
+            while (!aChoisi)
-                    case ConsoleKey.LeftArrow:
+            {
-                        --indice;
+                Utils.DessinerPion(couleurs[indice]);
-                        break;
+                Console.Write("\b\b\b");
-
+
-                    case ConsoleKey.RightArrow:
+                switch (Console.ReadKey(true).Key)
-                        ++indice;
+                {
-                        break;
+                    case ConsoleKey.Enter:
-
+                        aChoisi = true;
-                    case ConsoleKey.Escape:
+                        break;
+
+                    case ConsoleKey.LeftArrow:
+                        --indice;
+                        break;
+
+                    case ConsoleKey.RightArrow:
+                        ++indice;
+                        break;
+
+                    case ConsoleKey.Escape:
                         if (e.Indice != 0)
-                        {
+                        {
                             aChoisi = true;
                             indice = -2;
-                        }
+                        }
-                        break;
+                        break;
-
+
-                    default:
+                    default:
-                        break;
+                        break;
-                }
+                }
-
+
-                if (indice == -1)
+                if (indice == -1)
-                    indice = couleurs.Length - 1;
+                    indice = couleurs.Length - 1;
-                else if (indice == couleurs.Length)
+                else if (indice == couleurs.Length)
-                    indice = 0;
+                    indice = 0;
-            }
+            }
-
+
-            Console.TreatControlCAsInput = false;
+            Console.TreatControlCAsInput = false;
-            Console.CursorVisible = true;
+            Console.CursorVisible = true;
-
+
-            return indice != -2 ? new Jeton(couleurs[indice]) : null;
+            return indice != -2 ? new Jeton(couleurs[indice]) : null;
-        }
+        }
-
+
-        /// <summary>
+        /// <summary>
-        /// Gestionnaire d'événement pour l'ajout d'un jeton.
+        /// Ecoute l'événement en rapport avec l'ajout d'un jeton dans le code.
-        /// </summary>
+        /// <param name="sender">La classe qui appelle l'événement; ici Partie.</param>
-        public static void AjouterJeton(Object? sender, AjouterJetonEventArgs e)
+        /// <param name="e">L'instance de l'événement AjouterJetonEventArgs créée par Partie.</param>
-        {
+        /// </summary>
-            Utils.DessinerPion(e.Jeton.Couleur);
+        public static void AjouterJeton(Object? sender, AjouterJetonEventArgs e)
-        }
+        {
-
+            Utils.DessinerPion(e.Jeton.Couleur);
-        /// <summary>
+        }
-        /// Gestionnaire d'événement pour la suppression du dernier jeton ajouté.
+
-        /// </summary>
+        /// <summary>
-        public static void SupprimerDernierJeton(Object? sender, SupprimerDernierJetonEventArgs e)
+        /// Ecoute l'événement en rapport avec la suppression du dernier jeton ajouté dans le code.
-        {
+        /// <param name="sender">La classe qui appelle l'événement; ici Partie.</param>
-            Console.Write("\b\b\b      \b\b\b\b\b\b");
+        /// <param name="e">L'instance de l'événement SupprimerDernierJetonEventArgs créée par Partie.</param>
-        }
+        /// </summary>
-
+        public static void SupprimerDernierJeton(Object? sender, SupprimerDernierJetonEventArgs e)
-        /// <summary>
+        {
-        /// Gestionnaire d'événement pour l'ajout d'un code.
+            Console.Write("\b\b\b      \b\b\b\b\b\b");
-        /// </summary>
+        }
-        public static void AjouterCode(Object? sender, AjouterCodeEventArgs e)
+
-        {
+        /// <summary>
-            Console.WriteLine();
+        /// Ecoute l'événement en rapport avec l'ajout d'un code dans le plateau.
-
+        /// <param name="sender">La classe qui appelle l'événement; ici Partie.</param>
-            Utils.DessinerSeparateur();
+        /// <param name="e">L'instance de l'événement AjouterCodeEventArgs créée par Partie.</param>
-        }
+        /// </summary>
-
+        public static void AjouterCode(Object? sender, AjouterCodeEventArgs e)
-        /// <summary>
+        {
-        /// Gestionnaire d'événement pour la fin de la partie.
+            Console.WriteLine();
-        /// </summary>
+
-        public static void PartieTerminee(Object? sender, PartieTermineeEventArgs e)
+            Utils.DessinerSeparateur();
-        {
+        }
-            Joueur[] gagnants = e.Gagnants.ToArray();
+
-
+        /// <summary>
-            if (gagnants.Length > 1)
+        /// Ecoute l'événement en rapport avec la fin de la partie.
-            {
+        /// <param name="sender">La classe qui appelle l'événement; ici Partie.</param>
-                Console.WriteLine("C'est une égalité !");
+        /// <param name="e">L'instance de l'événement PartieTermineeEventArgs créée par Partie.</param>
-            }
+        /// </summary>
-            else if (gagnants.Length == 1)
+        public static void PartieTerminee(Object? sender, PartieTermineeEventArgs e)
-            {
+        {
-                Console.WriteLine($"C'est une victoire de {gagnants[0].Nom}.");
+            Joueur[] gagnants = e.Gagnants.ToArray();
-            }
+
-            else
+            if (gagnants.Length > 1)
-            {
+            {
-                Console.WriteLine("C'est une défaite des deux joueurs...");
+                Console.WriteLine("C'est une égalité !");
-            }
+            }
-        }
+            else if (gagnants.Length == 1)
-    }
+            {
-}
+                Console.WriteLine($"C'est une victoire de {gagnants[0].Nom}.");
+            }
+            else
+            {
+                Console.WriteLine("C'est une défaite des deux joueurs...");
+            }
+        }
+    }
+}

Sources/ConsoleApp/Program.cs

@@ -1,3 +1,8 @@
+/// <summary>
+/// Permet de jouer une partie de mastermind, avec les règles classiques 
+/// (2 joueurs, 12 tours, un code à 4 couleurs parmi 6)
+/// </summary>
+
 using ConsoleApp;
 using CoreLibrary;
 

Sources/ConsoleApp/Utils.cs

@@ -60,15 +60,17 @@ namespace ConsoleApp
             Console.Write(" ");
 
             // Sélectionne la couleur appropriée en fonction du type de pion (une couleur ou un indicateur)
+            // Si Couleur.ROUGE alors le fond sera ConsoleColor.Red
+            // Si Indicateur.BONNEPLACE alors le fond sera ConsoleColor.Black
             Console.ForegroundColor = pion.GetType().Equals(typeof(Couleur)) ?
                 couleursTerminal.GetValueOrDefault((Couleur)pion) :
                 indicateursTerminal.GetValueOrDefault((Indicateur)pion);
 
-            // Définit la couleur de fond en fonction de la couleur de premier plan
+            // Si la couleur du pion est noir, alors le fond devient blanc, sinon il reste noir
             Console.BackgroundColor = Console.ForegroundColor.Equals(ConsoleColor.Black) ? ConsoleColor.White : ConsoleColor.Black;
 
             Console.OutputEncoding = System.Text.Encoding.UTF8;
-            Console.Write("⬤");
+            Console.Write("O");
 
             Console.ResetColor();
 
@@ -84,11 +86,12 @@ namespace ConsoleApp
             foreach(Enum pion in ligne)
                 DessinerPion(pion);
 
+            // Ajoute des espaces s'il y a moins de 4 pions à dessiner
             Console.Write("".PadLeft((4 - ligne.Length) * 3));
         }
 
         /// <summary>
-        /// Dessine un plateau de jeu dans la console, affichant les jetons et les indicateurs.
+        /// Dessine un plateau de jeu dans la console, affichant les codes et leurs indicateurs.
         /// </summary>
         /// <param name="grille">La grille de jeu.</param>
         /// <param name="indicateurs">Les indicateurs associés à chaque ligne.</param>

Sources/CoreLibrary/Code.cs

@@ -30,7 +30,7 @@ namespace CoreLibrary
         }
 
         /// <summary>
-        /// Initialise une nouvelle instance de la class <see cref="Code"/> avec les jetons spécifiés.
+        /// Initialise une nouvelle instance de la classe <see cref="Code"/> avec les jetons spécifiés.
         /// </summary>
         /// <param name="jetons">Les jetons pour initaliser le code.</param>
         /// <exception cref="TailleCodeException">Levée lorsque la collection de jetons spécifiée est vide.</exception>

Sources/CoreLibrary/Events/AjouterCodeEventArgs.cs

@@ -1,20 +1,19 @@
-
+namespace CoreLibrary.Events
-namespace CoreLibrary.Events
 {
     /// <summary>
-    /// Représente les arguments d'événement pour l'événement de l'ajout d'un code.
+    /// Classe contenant les arguments passées en paramètre lors de l'événement AjouterCode.
     /// </summary>
     public class AjouterCodeEventArgs : EventArgs
     {
         /// <summary>
-        /// Obtient le code ajouté.
+        /// Le code ajouté.
         /// </summary>
         public Code Code { get; private set; }
 
         /// <summary>
         /// Initialise une nouvelle instance de la classe <see cref="AjouterCodeEventArgs"/> avec le code spécifié.
         /// </summary>
-        /// <param name="code">Le code à ajouter.</param>
+        /// <param name="code">Le code qui a été ajouté.</param>
         public AjouterCodeEventArgs(Code code) 
         {
             Code = code;

Sources/CoreLibrary/Events/AjouterJetonEventArgs.cs

@@ -1,21 +1,19 @@
-
+namespace CoreLibrary.Events
-
-namespace CoreLibrary.Events
 {
     /// <summary>
-    /// Représente les arguments d'événement pour l'événement d'ajout d'un jeton.
+    /// Classe contenant les arguments passées en paramètre lors de l'événement AjouterJeton.
     /// </summary>
     public class AjouterJetonEventArgs : EventArgs
     {
         /// <summary>
-        /// Obtient le jeton ajouté.
+        /// Le jeton ajouté.
         /// </summary>
         public Jeton Jeton { get; private set; }
 
         /// <summary>
         /// Initialise une nouvelle instance de la classe <see cref="AjouterJetonEventArgs"/> avec le jeton spécifié.
         /// </summary>
-        /// <param name="jeton">Le jeton à ajouter.</param>
+        /// <param name="jeton">Le jeton qui a été ajouté.</param>
         public AjouterJetonEventArgs(Jeton jeton) 
         {
             Jeton = jeton;

Sources/CoreLibrary/Events/AjouterJoueursEventArgs.cs

@@ -1,19 +1,19 @@
 namespace CoreLibrary.Events
 {
     /// <summary>
-    /// Représente les arguments d'événement pour l'événement d'ajout d'un joueur.
+    /// Classe contenant les arguments passées en paramètre lors de l'événement AjouterJoueur.
     /// </summary>
     public class AjouterJoueursEventArgs : EventArgs
     {
         /// <summary>
-        /// Obtient le joueur ajouté.
+        /// Le joueur ajouté.
         /// </summary>
         public Joueur Joueur { get; private set; }
 
         /// <summary>
         /// Initialise une nouvelle instance de la classe <see cref="AjouterJoueursEventArgs"/> avec le joueur spécifié.
         /// </summary>
-        /// <param name="joueur">Le joueur à ajouter.</param>
+        /// <param name="joueur">Le joueur qui a été ajouté.</param>
         public AjouterJoueursEventArgs(Joueur joueur) 
         {
             Joueur = joueur;

Sources/CoreLibrary/Events/DebutPartieEventArgs.cs

@@ -1,7 +1,7 @@
 namespace CoreLibrary.Events
 {
-    /// <summary>
+    // <summary>
-    /// Représente les arguments d'événement pour le début d'une partie.
+    /// Classe contenant les arguments passées en paramètre lors de l'événement DebutPartie
     /// </summary>
     public class DebutPartieEventArgs : EventArgs
     {

Sources/CoreLibrary/Events/DemanderJetonEventArgs.cs

@@ -1,13 +1,19 @@
-
+namespace CoreLibrary.Events
-namespace CoreLibrary.Events
 {
-    /// <summary>
+    /// <summary>
-    /// Représente les arguments d'événement pour la demande d'ajout d'un jeton.
+    /// Classe contenant les arguments passées en paramètre lors de l'événement DemanderJeton.
     /// </summary>
     public class DemanderJetonEventArgs : EventArgs
     {
+        /// <summary>
+        /// L'indice du code où le jeton va être ajouté.
+        /// </summary>
         public int Indice {  get; private set; }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="DemanderJetonEventArgs"/> avec l'indice spécifié.
+        /// </summary>
+        /// <param name="joueur">L'indice du jeton qui va été ajouté.</param>
         public DemanderJetonEventArgs(int indice) 
         {
             Indice = indice;

Sources/CoreLibrary/Events/DemanderJoueurEventArgs.cs

@@ -1,12 +1,12 @@
 namespace CoreLibrary.Events
 {
     /// <summary>
-    /// Représente les arguments d'événement pour la demande d'ajout d'un joueur.
+    /// Classe contenant les arguments passées en paramètre lors de l'événement DemanderJoueur.
     /// </summary>
     public class DemanderJoueurEventArgs : EventArgs
     {
         /// <summary>
-        /// Obtient le numéro du joueur à ajouter.
+        /// Le numéro du joueur (Joueur 1 ou 2, 3..).
         /// </summary>
         public int Numero { get; private set; }
 
@@ -14,7 +14,7 @@
         /// <summary>
         /// Initialise une nouvelle instance de la classe <see cref="DemanderJoueurEventArgs"/> avec le numéro du joueur spécifié.
         /// </summary>
-        /// <param name="numero">Le numéro du joueur à ajouter.</param>
+        /// <param name="numero">Le numéro du joueur qui va être ajouté.</param>
         public DemanderJoueurEventArgs(int numero)
         {
             Numero = numero;

Sources/CoreLibrary/Events/NouveauTourEventArgs.cs

@@ -1,29 +1,27 @@
-using CoreLibrary.Exceptions;
+namespace CoreLibrary.Events
-
-namespace CoreLibrary.Events
 {
     /// <summary>
-    /// Représente les arguments d'événement pour le début d'un nouveau tour.
+    /// Classe contenant les arguments passées en paramètre lors de l'événement NouveauTour.
     /// </summary>
     public class NouveauTourEventArgs : EventArgs
     {
         /// <summary>
-        /// Obtient le joueur dont c'est le tour.
+        /// Le joueur dont c'est le tour.
         /// </summary>
         public Joueur Joueur { get; private set; }
 
         /// <summary>
-        /// Obtient le numéro du tour.
+        /// Le numéro du tour.
         /// </summary>
         public int Tour {  get; private set; }
 
         /// <summary>
-        /// Obtient la grille du joueur actuelle.
+        /// La grille du joueur actuelle.
         /// </summary>
         public IEnumerable<IEnumerable<Jeton?>> Grille { get; private set; }
 
         /// <summary>
-        /// Obtient les indicateurs de la grille de jeu.
+        /// Les indicateurs de la grille de jeu.
         /// </summary>
         public IEnumerable<IEnumerable<Indicateur>> Indicateurs { get; private set; }
 

Sources/CoreLibrary/Events/PartieTermineeEventArgs.cs

@@ -1,31 +1,25 @@
-using System;
+namespace CoreLibrary.Events
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace CoreLibrary.Events
 {
     /// <summary>
-    /// Représente les arguments d'événement pour la fin d'une partie.
+    /// Classe contenant les arguments passées en paramètre lors de l'événement PartieTerminee.
     /// </summary>
     public class PartieTermineeEventArgs : EventArgs
     {
         /// <summary>
-        /// Obtient les joueurs gagnants de la partie.
+        /// Les joueurs gagnants de la partie.
         /// </summary>
         public IEnumerable<Joueur> Gagnants { get; private set; }
 
         /// <summary>
-        /// Obtient les joueurs perdants de la partie.
+        /// Les joueurs perdants de la partie.
         /// </summary>
         public IEnumerable<Joueur> Perdants { get; private set; }
 
         /// <summary>
         /// Initialise une nouvelle instance de la classe <see cref="PartieTermineeEventArgs"/> avec les gagnants et les perdants spécifiés.
         /// </summary>
-        /// <param name="gagnants">Les joueurs gagnants de la partie.</param>
+        /// <param name="gagnants">Les gagnants.</param>
-        /// <param name="perdants">Les joueurs perdants de la partie.</param>
+        /// <param name="perdants">Les perdants.</param>
         public PartieTermineeEventArgs(IEnumerable<Joueur> gagnants, IEnumerable<Joueur> perdants)
         {
             Gagnants = gagnants;

Sources/CoreLibrary/Events/PasserMainEventArgs.cs

@@ -1,7 +1,7 @@
 namespace CoreLibrary.Events
 {
     /// <summary>
-    /// Représente les arguments d'événement pour le passage de la main au joueur suivant.
+    /// Classe contenant les arguments passées en paramètre lors de l'événement PasserMain.
     /// </summary>
     public class PasserMainEventArgs : EventArgs
     {

Sources/CoreLibrary/Events/SupprimerDernierJetonEventArgs.cs

@@ -1,7 +1,7 @@
 namespace CoreLibrary.Events
 {
     /// <summary>
-    /// Représente les arguments d'événement pour la suppression du dernier jeton ajouté.
+    /// Classe contenant les arguments passées en paramètre lors de l'événement SupprimerDernierJeton.
     /// </summary>
     public class SupprimerDernierJetonEventArgs : EventArgs
     {

Sources/CoreLibrary/Exceptions/CodeCompletException.cs

@@ -8,17 +8,24 @@ namespace CoreLibrary.Exceptions
     [Serializable]
     public class CodeCompletException : Exception
     {
-        /// <summary>
+        // Message par défaut
-        /// Initialise une nouvelle instance de la classe <see cref="CodeCompletException"/>.
-        /// </summary>
         private const string messageDefaut = "Le code dans lequel vous essayez d'ajouter un jeton est déjà complet.";
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeCompletException"/> avec le message par défaut.
+        /// </summary>
         public CodeCompletException() : base(messageDefaut)
         {}
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeCompletException"/> avec le message spécifié.
+        /// </summary>
         public CodeCompletException(string message) : base(message)
         {}
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeCompletException"/> avec le message et l'exception parent spécifiés.
+        /// </summary>
         public CodeCompletException(string message, Exception exception) : base(message, exception)
         {}
 

Sources/CoreLibrary/Exceptions/CodeIncompletException.cs

@@ -8,17 +8,24 @@ namespace CoreLibrary.Exceptions
     [Serializable]
     public class CodeIncompletException : Exception
     {
-        /// <summary>
+        // Message par défaut
-        /// Initialise une nouvelle instance de la classe <see cref="CodeIncompletException"/>.
-        /// </summary>
         private const string messageDefaut = "Le code que vous essayez d'ajouter dans la grille n'est pas complet.";
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeIncompletException"/> avec le message par défaut.
+        /// </summary>
         public CodeIncompletException() : base(messageDefaut)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeIncompletException"/> avec le message spécifié.
+        /// </summary>
         public CodeIncompletException(string message) : base(message)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeIncompletException"/> avec le message et l'exception parent spécifié.
+        /// </summary>
         public CodeIncompletException(string message, Exception exception) : base(message, exception)
         { }
 

Sources/CoreLibrary/Exceptions/CodeInvalideException.cs

@@ -8,23 +8,33 @@ namespace CoreLibrary.Exceptions
     [Serializable]
     public class CodeInvalideException : Exception
     {
-        /// <summary>
+        // Message par défaut
-        /// Initialise une nouvelle instance de la classe <see cref="CodeInvalideException"/>.
-        /// </summary>
-        /// <param name="tailleCodeAjoute">La taille du code que vous essayez d'ajouter.</param>
-        /// <param name="tailleCodePlateau">La taille du code que le plateau attend.</param>
         private const string messageDefaut = "Le code que vous essayez d'ajouter est invalide.";
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeInvalideException"/> avec le message par défaut.
+        /// </summary>
         public CodeInvalideException() : base(messageDefaut)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeInvalideException"/> avec des attributs spécifiés.
+        /// </summary>
+        /// <param name="tailleCodeAjoute">La taille du code que vous essayez d'ajouter.</param>
+        /// <param name="tailleCodePlateau">La taille du code que le plateau attend.</param>
         public CodeInvalideException(int tailleCodeAjoute, int tailleCodePlateau) :
             base($"Le code que vous essayez d'ajouter est un code de taille {tailleCodeAjoute}, or le plateau attend un code de {tailleCodePlateau}.")
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeInvalideException"/> avec le message spécifié.
+        /// </summary>
         public CodeInvalideException(string message) : base(message)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeInvalideException"/> avec le message et l'exception parent spécifiés.
+        /// </summary>
         public CodeInvalideException(string message, Exception exception) : base(message, exception)
         { }
 

Sources/CoreLibrary/Exceptions/CodeVideException.cs

@@ -8,17 +8,24 @@ namespace CoreLibrary.Exceptions
     [Serializable]
     public class CodeVideException : Exception
     {
-        /// <summary>
+        // Message par défaut
-        /// Initialise une nouvelle instance de la classe <see cref="CodeVideException"/>.
-        /// </summary>
         private const string messageDefaut = "Le code dans lequel vous essayez de supprimer un jeton est déjà vide.";
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeVideException"/> avec le message par défaut.
+        /// </summary>
         public CodeVideException() : base(messageDefaut)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeVideException"/> avec le message spécifié.
+        /// </summary>
         public CodeVideException(string message) : base(message)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="CodeVideException"/> avec le message et l'exception parent spécifiés.
+        /// </summary>
         public CodeVideException(string message, Exception exception) : base(message, exception)
         { }
 

Sources/CoreLibrary/Exceptions/GrilleCompleteException.cs

@@ -8,17 +8,24 @@ namespace CoreLibrary.Exceptions
     [Serializable]
     public class GrilleCompleteException : Exception
     {
-        /// <summary>
+        // Message par défaut
-        /// Initialise une nouvelle instance de la classe <see cref="GrilleCompleteException"/>.
-        /// </summary>
         private const string messageDefaut = "La grille dans laquelle vous essayez d'ajouter un code est déjà complète.";
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="GrilleCompleteException"/> avec le message par défaut.
+        /// </summary>
         public GrilleCompleteException() : base(messageDefaut)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="GrilleCompleteException"/> avec le message spécifié.
+        /// </summary>
         public GrilleCompleteException(string message) : base(message)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="GrilleCompleteException"/> avec le message et l'exception parent spécifiés.
+        /// </summary>
         public GrilleCompleteException(string message, Exception exception) : base(message, exception)
         { }
 

Sources/CoreLibrary/Exceptions/IndiceCodeException.cs

@@ -8,23 +8,33 @@ namespace CoreLibrary.Exceptions
     [Serializable]
     public class IndiceCodeException : Exception
     {
-        /// <summary>
+        // Message par défaut
-        /// Initialise une nouvelle instance de la classe <see cref="IndiceCodeException"/>.
-        /// </summary>
-        /// <param name="indice">L'indice incorrect qui a été spécifié.</param>
-        /// <param name="indiceMax">L'indice maximum permis.</param>
         private const string messageDefaut = "L'indice du jeton que vous essayez de récupérer est hors de la plage valide.";
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="IndiceCodeException"/> avec le message par défaut.
+        /// </summary>
         public IndiceCodeException() : base(messageDefaut)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="IndiceCodeException"/> avec les attributs spécifiés.
+        /// </summary>
+        /// <param name="indice">L'indice incorrect qui a été spécifié.</param>
+        /// <param name="indiceMax">L'indice maximum permis.</param>
         public IndiceCodeException(int indice, int indiceMax) :
             base($"Vous avez essayé de récupérer le jeton à la place {indice}, mais son indice doit être compris entre 0 et {indiceMax}.")
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="IndiceCodeException"/> avec le message spécifié.
+        /// </summary>
         public IndiceCodeException(string message) : base(message)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="IndiceCodeException"/> avec le message et l'exception parent spécifiés.
+        /// </summary>
         public IndiceCodeException(string message, Exception exception) : base(message, exception)
         { }
 

Sources/CoreLibrary/Exceptions/PartieNonCommenceeException.cs

@@ -8,17 +8,24 @@ namespace CoreLibrary.Exceptions
     [Serializable]
     public class PartieNonCommenceeException : Exception
     {
-        /// <summary>
+        // Message par défaut
-        /// Initialise une nouvelle instance de la classe <see cref="PartieNonCommenceeException"/>.
-        /// </summary>
         private const string messageDefaut = "La partie n'a pas encore commencée.";
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="PartieNonCommenceeException"/> avec le message par défaut.
+        /// </summary>
         public PartieNonCommenceeException() : base(messageDefaut)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="PartieNonCommenceeException"/> avec le message spécifié.
+        /// </summary>
         public PartieNonCommenceeException(string message) : base(message)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="PartieNonCommenceeException"/> avec le message et l'exception parent spécifiés.
+        /// </summary>
         public PartieNonCommenceeException(string message, Exception exception) : base(message, exception)
         { }
 

Sources/CoreLibrary/Exceptions/TailleCodeException.cs

@@ -8,22 +8,31 @@ namespace CoreLibrary.Exceptions
     [Serializable]
     public class TailleCodeException : Exception
     {
-        /// <summary>
+        // Message par défaut
-        /// Initialise une nouvelle instance de la classe <see cref="TailleCodeException"/>.
-        /// </summary>
-        /// <param name="taille">La taille du code spécifiée.</param>
         private const string messageDefaut = "Un code doit avoir une taille positive non nulle.";
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="TailleCodeException"/> avec le message par défaut.
+        /// </summary>
         public TailleCodeException() : base(messageDefaut)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="TailleCodeException"/> avec l'attribut spécifié.
+        /// </summary>
         public TailleCodeException(int taille) :
             base($"Un code doit avoir une taille positive non nulle, or il a reçu {taille}.")
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="TailleCodeException"/> avec le message spécifié.
+        /// </summary>
         public TailleCodeException(string message) : base(message)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="TailleCodeException"/> avec le message et l'exception parent spécifiés.
+        /// </summary>
         public TailleCodeException(string message, Exception exception) : base(message, exception)
         { }
 

Sources/CoreLibrary/Exceptions/TailleGrilleException.cs

@@ -8,22 +8,32 @@ namespace CoreLibrary.Exceptions
     [Serializable]
     public class TailleGrilleException : Exception
     {
-        /// <summary>
+        // Message par défaut
-        /// Initialise une nouvelle instance de la classe <see cref="TailleGrilleException"/>.
-        /// </summary>
-        /// <param name="taille">La taille de grille spécifiée.</param>
         private const string messageDefaut = "Une grille doit avoir une taille positive non nulle.";
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="TailleGrilleException"/> avec le message par défaut.
+        /// </summary>
         public TailleGrilleException() : base(messageDefaut)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="TailleGrilleException"/> avec l'attribut spécifié.
+        /// <param name="taille">La taille de la grille.</param>
+        /// </summary>
         public TailleGrilleException(int taille) :
             base($"Une grille doit avoir une taille positive non nulle, or elle a reçu {taille}.")
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="TailleGrilleException"/> avec le message spécifié.
+        /// </summary>
         public TailleGrilleException(string message) : base(message)
         { }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="TailleGrilleException"/> avec le message et l'exception parent spécifiés.
+        /// </summary>
         public TailleGrilleException(string message, Exception exception) : base(message, exception)
         { }