Exercices de Modélisation Orientée Objet

Ces exercices sont conçus pour approfondir la compréhension des relations entre classes en C#, en se concentrant sur la logique du domaine et la structure des données plutôt que sur l'algorithmie. Chaque exercice propose un scénario, une solution de modélisation sous forme de tableau "Qui contient quoi", et un exemple de code C# minimaliste. Ils sont volontairement fait plus complexe. On doit focaliser sur la syntaxe, les validations, les exceptions.

---

Exercice 1 : Le Système Bancaire (Composition)

Énoncé

Modélisez un système bancaire simple. Une Banque possède plusieurs Clients. Chaque Client peut avoir une ou plusieurs ComptesBancaires.

Focus : Représenter la relation entre Clients et ComptesBancaires. Banque possède client qui possède ses comptes bancaire.

Solutionnaire de modélisation : Qui contient quoi ?

Classe Principale	Contient (Type de Propriété)	Détails de la Relation
Banque	List<Client>	Une banque gère ses clients.
Client	List<CompteBancaire>	Un client possède ses propres comptes.
CompteBancaire	(Aucune autre classe)	Contient des informations (solde, numéro de compte).

Diagramme de classes (Mermaid)

classDiagram
    class Banque {
        +«get»-«set»nomBanque:string
        +«get»-«set»clients:List~Client~
        +«create»Banque(nomBanque:string)
        +AjouterClient(client:Client):void
    }

    class Client {
        +«get»-«set»clientId:int
        +«get»-«set»nom:string
        +«get»-«set»comptes:List~CompteBancaire~
        +«create»Client(clientId:int, nom:string)
        +AjouterCompte(compte:CompteBancaire):void
    }

    class CompteBancaire {
        +«get»-«set»numeroCompte:string
        +«get»-«set»solde:decimal
        +«create»CompteBancaire(numeroCompte:string, solde:decimal)
    }

    Banque "1" -- "0..*" Client : gère
    Client "1" -- "1..*" CompteBancaire : possède

Consulter la solution de l'exercice 1

namespace SystemeBancaire
{
    /// <summary>
    /// Représente un compte bancaire avec un numéro et un solde.
    /// </summary>
    public class CompteBancaire
    {
        private string _numeroCompte;
        private decimal _solde;

        /// <summary>
        /// Initialise une nouvelle instance de la classe CompteBancaire.
        /// </summary>
        /// <param name="numeroCompte">Le numéro du compte.</param>
        /// <param name="solde">Le solde initial.</param>
        public CompteBancaire(string numeroCompte, decimal solde)
        {
            NumeroCompte = numeroCompte;
            Solde = solde;
        }

        /// <summary>
        /// Obtient ou définit le numéro du compte bancaire.
        /// </summary>
        public string NumeroCompte
        {
            get { return _numeroCompte; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(NumeroCompte), "Le numéro de compte ne peut pas être nul ou vide.");
                }
                _numeroCompte = value;
            }
        }

        /// <summary>
        /// Obtient ou définit le solde du compte bancaire.
        /// </summary>
        public decimal Solde
        {
            get { return _solde; }
            private set
            {
                if (value < 0)
                {
                    throw new ArgumentException("Le solde ne peut pas être négatif.", nameof(Solde));
                }
                _solde = value;
            }
        }
    }

    /// <summary>
    /// Représente un client de la banque.
    /// </summary>
    public class Client
    {
        private int _clientId;
        private string _nom;
        private List<CompteBancaire> _comptes;

        /// <summary>
        /// Initialise une nouvelle instance de la classe Client.
        /// </summary>
        /// <param name="clientId">L'identifiant unique du client.</param>
        /// <param name="nom">Le nom du client.</param>
        public Client(int clientId, string nom)
        {
            ClientId = clientId;
            Nom = nom;
            _comptes = new List<CompteBancaire>();
        }

        /// <summary>
        /// Ajoute un compte bancaire à la liste des comptes du client.
        /// </summary>
        /// <param name="compte">Le compte à ajouter.</param>
        public void AjouterCompte(CompteBancaire compte)
        {
            if (compte == null)
            {
                throw new ArgumentNullException(nameof(compte));
            }
            _comptes.Add(compte);
        }

        /// <summary>
        /// Obtient ou définit l'identifiant du client.
        /// </summary>
        public int ClientId
        {
            get { return _clientId; }
            private set
            {
                if (value <= 0)
                {
                    throw new ArgumentException("L'identifiant du client doit être supérieur à zéro.", nameof(ClientId));
                }
                _clientId = value;
            }
        }

        /// <summary>
        /// Obtient ou définit le nom du client.
        /// </summary>
        public string Nom
        {
            get { return _nom; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(Nom), "Le nom ne peut pas être nul ou vide.");
                }
                _nom = value;
            }
        }

        /// <summary>
        /// Obtient ou définit la liste des comptes bancaires du client.
        /// </summary>
        public List<CompteBancaire> Comptes
        {
            get { return _comptes; }
            private set
            {
                if (value == null)
                {
                    throw new ArgumentNullException(nameof(Comptes));
                }
                _comptes = value;
            }
        }
    }

    /// <summary>
    /// Représente une institution bancaire.
    /// </summary>
    public class Banque
    {
        private string _nomBanque;
        private List<Client> _clients;

        /// <summary>
        /// Initialise une nouvelle instance de la classe Banque.
        /// </summary>
        /// <param name="nomBanque">Le nom de la banque.</param>
        public Banque(string nomBanque)
        {
            NomBanque = nomBanque;
            _clients = new List<Client>();
        }

        /// <summary>
        /// Ajoute un client à la banque.
        /// </summary>
        /// <param name="client">Le client à ajouter.</param>
        public void AjouterClient(Client client)
        {
            if (client == null)
            {
                throw new ArgumentNullException(nameof(client));
            }
            _clients.Add(client);
        }

        /// <summary>
        /// Obtient ou définit le nom de la banque.
        /// </summary>
        public string NomBanque
        {
            get { return _nomBanque; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(NomBanque), "Le nom de la banque ne peut pas être nul ou vide.");
                }
                _nomBanque = value;
            }
        }

        /// <summary>
        /// Obtient ou définit la liste des clients de la banque.
        /// </summary>
        public List<Client> Clients
        {
            get { return _clients; }
            private set
            {
                if (value == null)
                {
                    throw new ArgumentNullException(nameof(Clients));
                }
                _clients = value;
            }
        }
    }
}

---

Exercice 2 : La Bibliothèque (Agrégation)

Énoncé

Modélisez une Bibliotheque qui gère une collection de Livres. Un Membre peut emprunter un Livre. Un livre peut exister indépendamment de la bibliothèque, et un membre peut exister indépendamment des emprunts. La relation d'emprunt est temporaire.

Focus : Illustrer la relation d'Agrégation, où les objets peuvent exister indépendamment de l'ensemble (un Livre existe sans la Bibliothèque, un Membre sans emprunter de Livre). Le lien entre Livre et Membre est une association simple.

Solutionnaire de modélisation : Qui contient quoi ?

Classe Principale	Contient (Type de Propriété)	Détails de la Relation
Bibliotheque	List<Livre>	Une bibliothèque possède une collection de livres.
Livre	Membre? (Optionnel)	Un livre peut être emprunté par un membre (lien temporaire).
Membre	List<Livre>	Un membre peut avoir plusieurs livres empruntés.

Diagramme de classes (Mermaid)

classDiagram
    class Bibliotheque {
        +«get»-«set»nom:string
        +«get»-«set»livresDisponibles:List~Livre~
        +«create»Bibliotheque(nom:string)
        +AjouterLivre(livre:Livre):void
        +RetirerLivre(livre:Livre):void
    }

    class Livre {
        +«get»-«set»titre:string
        +«get»-«set»auteur:string
        +«get»-«set»estEmprunte:bool
        +«get»-«set»emprunteurActuel:Membre?
        +«create»Livre(titre:string, auteur:string)
        +Emprunter(membre:Membre):void
        +Retourner():void
    }

    class Membre {
        +«get»-«set»membreId:int
        +«get»-«set»nom:string
        +«get»-«set»livresEmpruntes:List~Livre~
        +«create»Membre(membreId:int, nom:string)
        +EmprunterLivre(livre:Livre):void
        +RetournerLivre(livre:Livre):void
    }

    Bibliotheque "1" -- "0..*" Livre : possède
    Livre "0..*" -- "0..1" Membre : est emprunté par

Consulter la solution de l'exercice 2

namespace SystemeBibliotheque
{
    /// <summary>
    /// Représente un livre dans le système de bibliothèque.
    /// </summary>
    public class Livre
    {
        private string _titre;
        private string _auteur;
        private bool _estEmprunte;
        private Membre? _emprunteurActuel;

        /// <summary>
        /// Initialise une nouvelle instance de la classe Livre.
        /// </summary>
        /// <param name="titre">Le titre du livre.</param>
        /// <param name="auteur">L'auteur du livre.</param>
        public Livre(string titre, string auteur)
        {
            Titre = titre;
            Auteur = auteur;
            _estEmprunte = false;
            _emprunteurActuel = null;
        }

        /// <summary>
        /// Marque le livre comme étant emprunté par un membre.
        /// </summary>
        /// <param name="membre">Le membre qui emprunte le livre.</param>
        public void Emprunter(Membre membre)
        {
            if (membre == null)
            {
                throw new ArgumentNullException(nameof(membre));
            }

            if (!EstEmprunte)
            {
                EstEmprunte = true;
                EmprunteurActuel = membre;
            }
        }

        /// <summary>
        /// Marque le livre comme étant retourné.
        /// </summary>
        public void Retourner()
        {
            EstEmprunte = false;
            EmprunteurActuel = null;
        }

        /// <summary>
        /// Obtient ou définit le titre du livre.
        /// </summary>
        public string Titre
        {
            get { return _titre; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(Titre), "Le titre ne peut pas être nul ou vide.");
                }
                _titre = value;
            }
        }

        /// <summary>
        /// Obtient ou définit l'auteur du livre.
        /// </summary>
        public string Auteur
        {
            get { return _auteur; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(Auteur), "L'auteur ne peut pas être nul ou vide.");
                }
                _auteur = value;
            }
        }

        /// <summary>
        /// Obtient une valeur indiquant si le livre est emprunté.
        /// </summary>
        public bool EstEmprunte
        {
            get { return _estEmprunte; }
            private set { _estEmprunte = value; }
        }

        /// <summary>
        /// Obtient le membre qui a actuellement emprunté le livre.
        /// </summary>
        public Membre? EmprunteurActuel
        {
            get { return _emprunteurActuel; }
            private set { _emprunteurActuel = value; }
        }
    }

    /// <summary>
    /// Représente un membre de la bibliothèque.
    /// </summary>
    public class Membre
    {
        private int _membreId;
        private string _nom;
        private List<Livre> _livresEmpruntes;

        /// <summary>
        /// Initialise une nouvelle instance de la classe Membre.
        /// </summary>
        /// <param name="membreId">L'identifiant unique du membre.</param>
        /// <param name="nom">Le nom du membre.</param>
        public Membre(int membreId, string nom)
        {
            MembreId = membreId;
            Nom = nom;
            _livresEmpruntes = new List<Livre>();
        }

        /// <summary>
        /// Emprunte un livre s'il est disponible.
        /// </summary>
        /// <param name="livre">Le livre à emprunter.</param>
        public void EmprunterLivre(Livre livre)
        {
            if (livre == null)
            {
                throw new ArgumentNullException(nameof(livre));
            }

            if (!livre.EstEmprunte)
            {
                livre.Emprunter(this);
                _livresEmpruntes.Add(livre);
            }
        }

        /// <summary>
        /// Retourne un livre emprunté.
        /// </summary>
        /// <param name="livre">Le livre à retourner.</param>
        public void RetournerLivre(Livre livre)
        {
            if (livre == null)
            {
                throw new ArgumentNullException(nameof(livre));
            }

            if (_livresEmpruntes.Contains(livre))
            {
                livre.Retourner();
                _livresEmpruntes.Remove(livre);
            }
        }

        /// <summary>
        /// Obtient ou définit l'identifiant du membre.
        /// </summary>
        public int MembreId
        {
            get { return _membreId; }
            private set
            {
                if (value <= 0)
                {
                    throw new ArgumentException("L'identifiant du membre doit être supérieur à zéro.", nameof(MembreId));
                }
                _membreId = value;
            }
        }

        /// <summary>
        /// Obtient ou définit le nom du membre.
        /// </summary>
        public string Nom
        {
            get { return _nom; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(Nom), "Le nom ne peut pas être nul ou vide.");
                }
                _nom = value;
            }
        }

        /// <summary>
        /// Obtient ou définit la liste des livres empruntés par le membre.
        /// </summary>
        public List<Livre> LivresEmpruntes
        {
            get { return _livresEmpruntes; }
            private set
            {
                if (value == null)
                {
                    throw new ArgumentNullException(nameof(LivresEmpruntes));
                }
                _livresEmpruntes = value;
            }
        }
    }

    /// <summary>
    /// Représente une bibliothèque gérant une collection de livres.
    /// </summary>
    public class Bibliotheque
    {
        private string _nom;
        private List<Livre> _livresDisponibles;

        /// <summary>
        /// Initialise une nouvelle instance de la classe Bibliotheque.
        /// </summary>
        /// <param name="nom">Le nom de la bibliothèque.</param>
        public Bibliotheque(string nom)
        {
            Nom = nom;
            _livresDisponibles = new List<Livre>();
        }

        /// <summary>
        /// Ajoute un livre à la collection de la bibliothèque.
        /// </summary>
        /// <param name="livre">Le livre à ajouter.</param>
        public void AjouterLivre(Livre livre)
        {
            if (livre == null)
            {
                throw new ArgumentNullException(nameof(livre));
            }
            _livresDisponibles.Add(livre);
        }

        /// <summary>
        /// Retire un livre de la collection de la bibliothèque.
        /// </summary>
        /// <param name="livre">Le livre à retirer.</param>
        public void RetirerLivre(Livre livre)
        {
            if (livre == null)
            {
                throw new ArgumentNullException(nameof(livre));
            }
            _livresDisponibles.Remove(livre);
        }

        /// <summary>
        /// Obtient ou définit le nom de la bibliothèque.
        /// </summary>
        public string Nom
        {
            get { return _nom; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(Nom), "Le nom de la bibliothèque ne peut pas être nul ou vide.");
                }
                _nom = value;
            }
        }

        /// <summary>
        /// Obtient ou définit la liste des livres disponibles dans la bibliothèque.
        /// </summary>
        public List<Livre> LivresDisponibles
        {
            get { return _livresDisponibles; }
            private set
            {
                if (value == null)
                {
                    throw new ArgumentNullException(nameof(LivresDisponibles));
                }
                _livresDisponibles = value;
            }
        }
    }
}

---

Exercice 3 : Le Système de Cours (Classe Pivot / Association)

Énoncé

Modélisez un système où un Professeur enseigne un Cours à plusieurs Etudiants. Le Cours est l'entité centrale qui fait le lien entre un professeur et une liste d'étudiants.

Focus : Montrer comment une classe (le Cours) peut agir comme un point de rencontre ou une "classe pivot" pour établir des relations entre d'autres entités.

Solutionnaire de modélisation : Qui contient quoi ?

Classe Principale	Contient (Type de Propriété)	Détails de la Relation
Cours	Professeur	Un cours est donné par un unique professeur.
Cours	List<Etudiant>	Un cours est suivi par plusieurs étudiants.
Professeur	List<Cours>	Un professeur peut enseigner plusieurs cours.

Diagramme de classes (Mermaid)

classDiagram
    class Professeur {
        +«get»-«set»professeurId:int
        +«get»-«set»nom:string
        +«get»-«set»coursEnseignes:List~Cours~
        +«create»Professeur(professeurId:int, nom:string)
        +AjouterCours(cours:Cours):void
    }

    class Etudiant {
        +«get»-«set»etudiantId:int
        +«get»-«set»nom:string
        +«create»Etudiant(etudiantId:int, nom:string)
    }

    class Cours {
        +«get»-«set»coursId:int
        +«get»-«set»titre:string
        +«get»-«set»enseignant:Professeur
        +«get»-«set»etudiantsInscrits:List~Etudiant~
        +«create»Cours(coursId:int, titre:string, enseignant:Professeur)
        +InscrireEtudiant(etudiant:Etudiant):void
    }

    Professeur "1" -- "0..*" Cours : enseigne
    Cours "0..*" -- "0..*" Etudiant : contient

Consulter la solution de l'exercice 3

namespace SystemeCours
{
    /// <summary>
    /// Représente un professeur enseignant des cours.
    /// </summary>
    public class Professeur
    {
        private int _professeurId;
        private string _nom;
        private List<Cours> _coursEnseignes;

        /// <summary>
        /// Initialise une nouvelle instance de la classe Professeur.
        /// </summary>
        /// <param name="professeurId">L'identifiant du professeur.</param>
        /// <param name="nom">Le nom du professeur.</param>
        public Professeur(int professeurId, string nom)
        {
            ProfesseurId = professeurId;
            Nom = nom;
            _coursEnseignes = new List<Cours>();
        }

        /// <summary>
        /// Ajoute un cours à la liste des cours enseignés par le professeur.
        /// </summary>
        /// <param name="cours">Le cours à ajouter.</param>
        public void AjouterCours(Cours cours)
        {
            if (cours == null)
            {
                throw new ArgumentNullException(nameof(cours));
            }

            if (!_coursEnseignes.Contains(cours))
            {
                _coursEnseignes.Add(cours);
            }
        }

        /// <summary>
        /// Obtient ou définit l'identifiant du professeur.
        /// </summary>
        public int ProfesseurId
        {
            get { return _professeurId; }
            private set
            {
                if (value <= 0)
                {
                    throw new ArgumentException("L'identifiant du professeur doit être supérieur à zéro.", nameof(ProfesseurId));
                }
                _professeurId = value;
            }
        }

        /// <summary>
        /// Obtient ou définit le nom du professeur.
        /// </summary>
        public string Nom
        {
            get { return _nom; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(Nom), "Le nom ne peut pas être nul ou vide.");
                }
                _nom = value;
            }
        }

        /// <summary>
        /// Obtient ou définit la liste des cours enseignés par le professeur.
        /// </summary>
        public List<Cours> CoursEnseignes
        {
            get { return _coursEnseignes; }
            private set
            {
                if (value == null)
                {
                    throw new ArgumentNullException(nameof(CoursEnseignes));
                }
                _coursEnseignes = value;
            }
        }
    }

    /// <summary>
    /// Représente un étudiant.
    /// </summary>
    public class Etudiant
    {
        private int _etudiantId;
        private string _nom;

        /// <summary>
        /// Initialise une nouvelle instance de la classe Etudiant.
        /// </summary>
        /// <param name="etudiantId">L'identifiant de l'étudiant.</param>
        /// <param name="nom">Le nom de l'étudiant.</param>
        public Etudiant(int etudiantId, string nom)
        {
            EtudiantId = etudiantId;
            Nom = nom;
        }

        /// <summary>
        /// Obtient ou définit l'identifiant de l'étudiant.
        /// </summary>
        public int EtudiantId
        {
            get { return _etudiantId; }
            private set
            {
                if (value <= 0)
                {
                    throw new ArgumentException("L'identifiant de l'étudiant doit être supérieur à zéro.", nameof(EtudiantId));
                }
                _etudiantId = value;
            }
        }

        /// <summary>
        /// Obtient ou définit le nom de l'étudiant.
        /// </summary>
        public string Nom
        {
            get { return _nom; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(Nom), "Le nom ne peut pas être nul ou vide.");
                }
                _nom = value;
            }
        }
    }

    /// <summary>
    /// Représente un cours faisant le lien entre un professeur et des étudiants.
    /// </summary>
    public class Cours
    {
        private int _coursId;
        private string _titre;
        private Professeur _enseignant;
        private List<Etudiant> _etudiantsInscrits;

        /// <summary>
        /// Initialise une nouvelle instance de la classe Cours.
        /// </summary>
        /// <param name="coursId">L'identifiant du cours.</param>
        /// <param name="titre">Le titre du cours.</param>
        /// <param name="enseignant">Le professeur enseignant le cours.</param>
        public Cours(int coursId, string titre, Professeur enseignant)
        {
            if (enseignant == null)
            {
                throw new ArgumentNullException(nameof(enseignant));
            }

            CoursId = coursId;
            Titre = titre;
            Enseignant = enseignant;
            _etudiantsInscrits = new List<Etudiant>();
            enseignant.AjouterCours(this);
        }

        /// <summary>
        /// Inscrit un étudiant au cours.
        /// </summary>
        /// <param name="etudiant">L'étudiant à inscrire.</param>
        public void InscrireEtudiant(Etudiant etudiant)
        {
            if (etudiant == null)
            {
                throw new ArgumentNullException(nameof(etudiant));
            }

            if (!_etudiantsInscrits.Contains(etudiant))
            {
                _etudiantsInscrits.Add(etudiant);
            }
        }

        /// <summary>
        /// Obtient ou définit l'identifiant du cours.
        /// </summary>
        public int CoursId
        {
            get { return _coursId; }
            private set
            {
                if (value <= 0)
                {
                    throw new ArgumentException("L'identifiant du cours doit être supérieur à zéro.", nameof(CoursId));
                }
                _coursId = value;
            }
        }

        /// <summary>
        /// Obtient ou définit le titre du cours.
        /// </summary>
        public string Titre
        {
            get { return _titre; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(Titre), "Le titre ne peut pas être nul ou vide.");
                }
                _titre = value;
            }
        }

        /// <summary>
        /// Obtient ou définit le professeur enseignant le cours.
        /// </summary>
        public Professeur Enseignant
        {
            get { return _enseignant; }
            private set
            {
                if (value == null)
                {
                    throw new ArgumentNullException(nameof(Enseignant));
                }
                _enseignant = value;
            }
        }

        /// <summary>
        /// Obtient ou définit la liste des étudiants inscrits au cours.
        /// </summary>
        public List<Etudiant> EtudiantsInscrits
        {
            get { return _etudiantsInscrits; }
            private set
            {
                if (value == null)
                {
                    throw new ArgumentNullException(nameof(EtudiantsInscrits));
                }
                _etudiantsInscrits = value;
            }
        }
    }
}

---

Exercice 4 : Le Cabinet Médical (Classe d'Association)

Énoncé

Modélisez un système de cabinet médical. Un Medecin reçoit plusieurs Patients. La relation entre un médecin et un patient n'est pas directe, mais passe par un RendezVous, qui contient des informations spécifiques à cette rencontre (date, heure, motif).

Focus : Illustrer la Classe d'Association, où la relation entre deux entités est elle-même une entité avec ses propres attributs.

Solutionnaire de modélisation : Qui contient quoi ?

Classe Principale	Contient (Type de Propriété)	Détails de la Relation
Medecin	List<RendezVous>	Un médecin possède son calendrier de rendez-vous.
RendezVous	Medecin	Un rendez-vous est lié à un médecin.
RendezVous	Patient	Un rendez-vous concerne un patient.

Diagramme de classes (Mermaid)

classDiagram
    class Patient {
        +«get»-«set»patientId:int
        +«get»-«set»nom:string
        +«create»Patient(patientId:int, nom:string)
    }

    class Medecin {
        +«get»-«set»medecinId:int
        +«get»-«set»nom:string
        +«get»-«set»specialite:string
        +«get»-«set»rendezVousPlanifies:List~RendezVous~
        +«create»Medecin(medecinId:int, nom:string, specialite:string)
    }

    class RendezVous {
        +«get»-«set»rendezVousId:int
        +«get»-«set»dateHeure:DateTime
        +«get»-«set»motif:string
        +«get»-«set»medecin:Medecin
        +«get»-«set»patient:Patient
        +«create»RendezVous(rendezVousId:int, dateHeure:DateTime, motif:string, medecin:Medecin, patient:Patient)
    }

    Medecin "1" -- "0..*" RendezVous : possède
    RendezVous "0..*" -- "1" Patient : concerne

Consulter la solution de l'exercice 4

namespace CabinetMedical
{
    /// <summary>
    /// Représente un patient d'un cabinet médical.
    /// </summary>
    public class Patient
    {
        private int _patientId;
        private string _nom;

        /// <summary>
        /// Initialise une nouvelle instance de la classe Patient.
        /// </summary>
        /// <param name="patientId">L'identifiant du patient.</param>
        /// <param name="nom">Le nom du patient.</param>
        public Patient(int patientId, string nom)
        {
            PatientId = patientId;
            Nom = nom;
        }

        /// <summary>
        /// Obtient ou définit l'identifiant du patient.
        /// </summary>
        public int PatientId
        {
            get { return _patientId; }
            private set
            {
                if (value <= 0)
                {
                    throw new ArgumentException("L'identifiant du patient doit être supérieur à zéro.", nameof(PatientId));
                }
                _patientId = value;
            }
        }

        /// <summary>
        /// Obtient ou définit le nom du patient.
        /// </summary>
        public string Nom
        {
            get { return _nom; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(Nom), "Le nom ne peut pas être nul ou vide.");
                }
                _nom = value;
            }
        }
    }

    /// <summary>
    /// Représente un médecin exerçant dans un cabinet médical.
    /// </summary>
    public class Medecin
    {
        private int _medecinId;
        private string _nom;
        private string _specialite;
        private List<RendezVous> _rendezVousPlanifies;

        /// <summary>
        /// Initialise une nouvelle instance de la classe Medecin.
        /// </summary>
        /// <param name="medecinId">L'identifiant du médecin.</param>
        /// <param name="nom">Le nom du médecin.</param>
        /// <param name="specialite">La spécialité du médecin.</param>
        public Medecin(int medecinId, string nom, string specialite)
        {
            MedecinId = medecinId;
            Nom = nom;
            Specialite = specialite;
            _rendezVousPlanifies = new List<RendezVous>();
        }

        /// <summary>
        /// Obtient ou définit l'identifiant du médecin.
        /// </summary>
        public int MedecinId
        {
            get { return _medecinId; }
            private set
            {
                if (value <= 0)
                {
                    throw new ArgumentException("L'identifiant du médecin doit être supérieur à zéro.", nameof(MedecinId));
                }
                _medecinId = value;
            }
        }

        /// <summary>
        /// Obtient ou définit le nom du médecin.
        /// </summary>
        public string Nom
        {
            get { return _nom; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(Nom), "Le nom ne peut pas être nul ou vide.");
                }
                _nom = value;
            }
        }

        /// <summary>
        /// Obtient ou définit la spécialité du médecin.
        /// </summary>
        public string Specialite
        {
            get { return _specialite; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(Specialite), "La spécialité ne peut pas être nulle ou vide.");
                }
                _specialite = value;
            }
        }

        /// <summary>
        /// Obtient ou définit l'historique des rendez-vous planifiés par le médecin.
        /// </summary>
        public List<RendezVous> RendezVousPlanifies
        {
            get { return _rendezVousPlanifies; }
            private set
            {
                if (value == null)
                {
                    throw new ArgumentNullException(nameof(RendezVousPlanifies));
                }
                _rendezVousPlanifies = value;
            }
        }
    }

    /// <summary>
    /// Représente un rendez-vous entre un médecin et un patient.
    /// </summary>
    public class RendezVous
    {
        private int _rendezVousId;
        private DateTime _dateHeure;
        private string _motif;
        private Medecin _medecin;
        private Patient _patient;

        /// <summary>
        /// Initialise une nouvelle instance de la classe RendezVous.
        /// </summary>
        /// <param name="rendezVousId">L'identifiant du rendez-vous.</param>
        /// <param name="dateHeure">La date et l'heure du rendez-vous.</param>
        /// <param name="motif">Le motif du rendez-vous.</param>
        /// <param name="medecin">Le médecin concerné.</param>
        /// <param name="patient">Le patient concerné.</param>
        public RendezVous(int rendezVousId, DateTime dateHeure, string motif, Medecin medecin, Patient patient)
        {
            if (medecin == null)
            {
                throw new ArgumentNullException(nameof(medecin));
            }
            if (patient == null)
            {
                throw new ArgumentNullException(nameof(patient));
            }

            RendezVousId = rendezVousId;
            DateHeure = dateHeure;
            Motif = motif;
            Medecin = medecin;
            Patient = patient;

            _medecin.RendezVousPlanifies.Add(this);
        }

        /// <summary>
        /// Obtient ou définit l'identifiant du rendez-vous.
        /// </summary>
        public int RendezVousId
        {
            get { return _rendezVousId; }
            private set
            {
                if (value <= 0)
                {
                    throw new ArgumentException("L'identifiant du rendez-vous doit être supérieur à zéro.", nameof(RendezVousId));
                }
                _rendezVousId = value;
            }
        }

        /// <summary>
        /// Obtient ou définit la date et l'heure du rendez-vous.
        /// </summary>
        public DateTime DateHeure
        {
            get { return _dateHeure; }
            set { _dateHeure = value; }
        }

        /// <summary>
        /// Obtient ou définit le motif du rendez-vous.
        /// </summary>
        public string Motif
        {
            get { return _motif; }
            private set
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    throw new ArgumentNullException(nameof(Motif), "Le motif ne peut pas être nul ou vide.");
                }
                _motif = value;
            }
        }

        /// <summary>
        /// Obtient ou définit le médecin associé au rendez-vous.
        /// </summary>
        public Medecin Medecin
        {
            get { return _medecin; }
            private set
            {
                if (value == null)
                {
                    throw new ArgumentNullException(nameof(Medecin));
                }
                _medecin = value;
            }
        }

        /// <summary>
        /// Obtient ou définit le patient associé au rendez-vous.
        /// </summary>
        public Patient Patient
        {
            get { return _patient; }
            private set
            {
                if (value == null)
                {
                    throw new ArgumentNullException(nameof(Patient));
                }
                _patient = value;
            }
        }
    }
}