Ajout de commentaires

Sources/Modele/Banque.cs

@@ -6,11 +6,29 @@ using System.Threading.Tasks;
 
 namespace Model
 {
+    /// <summary>
+    /// Permet la création d'instances de banques.
+    /// </summary>
     public class Banque
     {
+        /// <summary>
+        /// Nom est un string servant à identifier une banque.
+        /// </summary>
         public string Nom { get; private set; }
+
+        /// <summary>
+        /// UrlSite sert à identifier l'URL du site de la banque.
+        /// </summary>
         public string UrlSite { get; private set; }
+
+        /// <summary>
+        /// UrlLogo sert à obtenir le logo de la banque.
+        /// </summary>
         public string UrlLogo { get; private set; }
+
+        /// <summary>
+        /// ListeDesComptes sert à stocker tous les comptes dont dispose la personne sur cet banque.
+        /// </summary>
         public List<Compte> ListeDesComptes { get; private set; } = new List<Compte>();
 
         public Banque(string nom, string urlSite, string urlLogo)
@@ -28,16 +46,29 @@ namespace Model
             ListeDesComptes = lescomptes;
         }
 
+        /// <summary>
+        /// Permet d'ajouter un compte à ListeDesComptes
+        /// </summary>
+        /// <param name="compte"> Compte à ajouter à la liste ListeDesComptes </param>
         public void AjouterCompte(Compte compte)
         {
             ListeDesComptes.Add(compte);
         }
 
+        /// <summary>
+        /// Permet de supprimer un compte à ListeDesComptes 
+        /// </summary>
+        /// <param name="compte"> Représente le compte qui doit être supprimer de ListeDesComptes. </param>
         public void SupprimerCompte(Compte compte)
         {
             ListeDesComptes.Remove(compte);
         }
 
+        /// <summary>
+        /// Permet de vérifier si un compte dont le nom est passé en paramètre existe bien dans ListeDesComptes.
+        /// </summary>
+        /// <param name="s"> Nom du compte dont on souhaite savoir si il est présent dans ListeDesComptes. </param>
+        /// <returns> Boolean égale à True si le compte existe dans la liste.</returns>
         public bool ExisteCompte(string s)
         {
             foreach (Compte compte in ListeDesComptes)
@@ -47,6 +78,13 @@ namespace Model
             }
             return false;
         }
+
+        /// <summary>
+        /// Permet d'obtenir le compte dont le nom est passé en paramètre dans la ListeDesComptes.
+        /// </summary>
+        /// <param name="s"> Nom du compte que l'on souhaite retourner. </param>
+        /// <returns> L'objet de type compte que l'on souhaite retourner. </returns>
+
         public Compte ReturnCompte(string s)
         {
             foreach (Compte compte in ListeDesComptes)
@@ -56,6 +94,5 @@ namespace Model
             }
             throw new KeyNotFoundException();
         }
-
     }
 }

Sources/Modele/Compte.cs

@@ -1,12 +1,35 @@
 namespace Model
 {
+    /// <summary>
+    /// Permet de créer et gérer des objets de type compte.
+    /// </summary>
     public class Compte
     {
+        /// <summary>
+        /// Représente le nom du compte.
+        /// </summary>
         public string Nom { get; private set; }
+
+        /// <summary>
+        /// Représente le solde présent sur ce compte.
+        /// </summary>
         public double Solde { get; private set; }
+
+        /// <summary>
+        /// Liste de toutes les opérations présent sur ce compte.
+        /// </summary>
         public List<Operation> LesOpe { get; private set; } = new List<Operation>();
+
+        /// <summary>
+        /// Liste de toutes les planifications présent sur ce compte.
+        /// </summary>
         public List<Planification> LesPla { get; private set; } = new List<Planification>();
+
+        /// <summary>
+        /// Liste de toutes les échéanciers présent sur ce compte.
+        /// </summary>
         public List<Echeance> LesEch { get; private set; } = new List<Echeance>();
+
         public Compte(string nom, double solde)
         {
             Nom = nom;
@@ -15,12 +38,14 @@
             LesPla = new List<Planification>();
             LesEch = new List<Echeance>();
         }
+
         public Compte(string nom, double solde, List<Operation> lesOpe)
         {
             Nom = nom;
             Solde = solde;
             LesOpe = lesOpe;
         }
+
         public Compte(string nom, double solde, List<Operation> lesOpe, List<Planification> lesPla)
         {
             Nom = nom;
@@ -36,11 +61,21 @@
             LesPla = lesPla;
             LesEch = lesEch;
         }
+
+        /// <summary>
+        /// Permet de modifier le solde présent sur le compte.
+        /// </summary>
+        /// <param name="s">Nouvelle quantité d'argent présent sur le compte.</param>
         public void modifierSolde(double s)
         {
             Solde = s;
         }
 
+        /// <summary>
+        /// Sert à ajouter une opération à la liste LesOpe
+        /// </summary>
+        /// <param name="o">Objet de type operation à ajouter à la liste</param>
+        /// <exception cref="NullReferenceException">Déclenchée quand l'opération placé en paramètre est nulle.</exception>
         public void ajouterOperation(Operation o)
         {
             if (o == null) throw new NullReferenceException();
@@ -52,36 +87,61 @@
             throw new NotImplementedException();
         }
 
+        /// <summary>
+        /// Permet de supprimer une operation de la liste LesOpe
+        /// </summary>
+        /// <param name="o">Objet de type operation devant être supprimé de la liste</param>
         public void supprimerOperation(Operation o)
         {
             LesOpe.Remove(o);
         }
 
+        /// <summary>
+        /// Sert à ajouter une echenance à la liste LesEch
+        /// </summary>
+        /// <param name="e">Objet de type échéance à ajouter à la liste</param>
+        /// <exception cref="NullReferenceException">Déclenchée quand l'opération placé en paramètre est nulle.</exception>
         public void ajoutEcheance(Echeance e)
         {
             if(e == null) throw new NullReferenceException();
             LesEch.Add(e);
         }
 
+        /// <summary>
+        /// Permet de supprimer une echeance de la liste LesEch
+        /// </summary>
+        /// <param name="e">Objet de type echeance devant être supprimé de la liste</param>
         public void supprimerEcheance(Echeance e)
         {
             LesEch.Remove(e);
         }
 
-        public void ajoutPlannification(Planification p)
+        /// <summary>
+        /// Sert à ajouter une planification à la liste LesPla
+        /// </summary>
+        /// <param name="p">Objet de type planification à ajouter à la liste</param>
+        /// <exception cref="NullReferenceException">Déclenchée quand l'opération placé en paramètre est nulle.</exception>
+        public void ajoutPlanification(Planification p)
         {
             if(p == null) throw new NullReferenceException();
             LesPla.Add(p);
         }
 
-        public void supprimerPlannification(Planification p)
+        /// <summary>
+        /// Permet de supprimer une planification de la liste LesPla
+        /// </summary>
+        /// <param name="p">Objet de type planification devant être supprimé de la liste</param>
+        public void supprimerPlanification(Planification p)
         {
             LesPla.Remove(p);
         }
 
+        /// <summary>
+        /// Permet de rédéfinir la méthode Equals en comparant le type des 2 objets.
+        /// </summary>
+        /// <param name="obj">L'objet dont on souhaite savoir s'il est de type compte</param>
         public override bool Equals(object obj)
         {
-
             if (obj == null || GetType() != obj.GetType())
             {
                 return false;
@@ -95,5 +155,6 @@
             return base.GetHashCode();
         }
 
+        /// <remarks> Si quelqu'un à le temps, utiliser des templates pour améliorer la qualité du code.</remarks>
     }
 }