diff --git a/Sources/CoreLibrary/Code.cs b/Sources/CoreLibrary/Code.cs
index 54dbcd0..c6b61fd 100644
--- a/Sources/CoreLibrary/Code.cs
+++ b/Sources/CoreLibrary/Code.cs
@@ -1,13 +1,28 @@
 using CoreLibrary.Exceptions;
 
+
+
+
+
 namespace CoreLibrary
 {
+    /// <summary>
+    /// Représente un code composé de jetons.
+    /// </summary>
     public class Code
     {
         private readonly Jeton?[] lesJetons;
 
+        /// <summary>
+        /// Obtenir le nombre de jetons dans le code.
+        /// </summary>
         public int NbJetons { get; private set; } = 0;
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la classe <see cref="Code"/> avec la longueur de code spécifiée.
+        /// </summary>
+        /// <param name="tailleCode">La longueur du code.</param>
+        /// <exception cref="TailleCodeException">Levée lorsque la longueur du code spécifiée est inférieure ou égale à zéro.</exception>
         public Code(int tailleCode)
         {       
             if(tailleCode <= 0)
@@ -18,6 +33,11 @@ namespace CoreLibrary
             lesJetons = new Jeton?[tailleCode];
         }
 
+        /// <summary>
+        /// Initialise une nouvelle instance de la class <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>
         public Code(IEnumerable<Jeton> jetons)
         {
             if (jetons.Count() == 0)
@@ -32,6 +52,11 @@ namespace CoreLibrary
             }
         }
 
+        /// <summary>
+        /// Ajoute un jeton au code.
+        /// </summary>
+        /// <param name="jeton">Le jeton à ajouter</param>
+        /// <exception cref="CodeCompletException">Levée lorsque le code est plein.</exception>
         public void AjouterJeton(Jeton jeton)
         {
             if (NbJetons == TailleMaximale())
@@ -42,6 +67,10 @@ namespace CoreLibrary
             lesJetons[NbJetons++] = jeton;
         }
 
+        /// <summary>
+        /// Supprime le dernier jeton ajouté au code.
+        /// </summary>
+        /// <exception cref="CodeVideException">Levée lorsque le code est vide.</exception>
         public void SupprimerDernierJeton()
         {
             if(NbJetons == 0)
@@ -52,6 +81,12 @@ namespace CoreLibrary
             lesJetons[--NbJetons] = null;
         }
 
+        /// <summary>
+        /// Récupère le jeton à l'indice spécifié dans le code.
+        /// </summary>
+        /// <param name="indice">L'indice du jeton a récupéré.</param>
+        /// <returns>Le jeton situé à l'indice spécifié.</returns>
+        /// <exception cref="IndiceCodeException">Levée lorsque l'indice est supérieur à la taille maximale du code, inférieur à 0 ou qu'il n'y a pas de jeton à l'indice spécifié</exception>
         public Jeton RecupererJeton(int indice)
         {
             if(indice < 0 || indice > TailleMaximale())
@@ -65,33 +100,57 @@ namespace CoreLibrary
             return jeton.Value;
         }
 
+        /// <summary>
+        /// Récupère une énumération des jetons dans le code.
+        /// </summary>
+        /// <returns>Enumération des jetons du code</returns>
         public IEnumerable<Jeton?> Jetons()
         {
             return lesJetons;
         }
 
+
+
+        /// <summary>
+        /// Vérifie si le code est complet.
+        /// </summary>
+        /// <returns>True si le code est complet, sinon False.</returns>
         public bool EstComplet()
         {
             return NbJetons == lesJetons.Length;
         }
 
+        /// <summary>
+        /// Recupère la taille maximal du code.
+        /// </summary>
+        /// <returns>Taille maximal du code.</returns>
         public int TailleMaximale()
         {
             return lesJetons.Length;
         }
 
+
+        /// <summary>
+        /// Compare le code avec un autre code et génère des indcateurs de correspondance.
+        /// </summary>
+        /// <param name="autreCode">Le code à comparer avec le code actuel</param>
+        /// <returns>Enumération d'indicateurs de correspondance entre les deux codes.</returns>
         public IEnumerable<Indicateur> Comparer(Code autreCode)
         {
             // Mon code est le code correct, l'autre code est celui qui teste
 
             Indicateur[] indicateurs = [];
 
+            /// Vérifie si les deux codes sont complets
             if (!EstComplet() || !autreCode.EstComplet())
                 return indicateurs;
 
+            /// Convertie les jetons des codes en tableaux.
             Jeton?[] mesJetons = Jetons().ToArray();
             Jeton?[] sesJetons = autreCode.Jetons().ToArray();
 
+            /// Compare les jetons pour détecter les ceux à la bonnes places
+            /// S'ils sont à la bonne place alors ils sont enlever du tableau et un indicateur BONNEPLACE est ajouter au tableau des indicateurs.
             for (int i = 0; i < mesJetons.Length; ++i)
             {
                 Jeton? monJeton = mesJetons[i];
@@ -106,6 +165,8 @@ namespace CoreLibrary
             }
 
 
+            /// Compare les jetons pour détecter ceux qui ont la bonne couleur.
+            /// S'ils ont la bonne couleur alors ils sont enlever du tableau et un indicateur BONNECOULEUR est ajouter au tableau des indicateurs.
             for (int i = 0; i < sesJetons.Length; ++i)
             {
                 Jeton? sonJeton = sesJetons[i];