diff --git a/Webzine.Repository.Contracts/IStyleRepository.cs b/Webzine.Repository.Contracts/IStyleRepository.cs
index ba078d9..2630fc7 100644
--- a/Webzine.Repository.Contracts/IStyleRepository.cs
+++ b/Webzine.Repository.Contracts/IStyleRepository.cs
@@ -2,16 +2,40 @@ using Webzine.Entity;
 
 namespace Webzine.Repository.Contracts
 {
+    /// <summary>
+    /// Interface définissant les opérations de base pour le repository de styles, permettant d'ajouter, supprimer, trouver et mettre à jour des styles dans la source de données.
+    /// </summary>
     public interface IStyleRepository
     {
+        /// <summary>
+        /// Ajoute un style à la liste des styles.
+        /// </summary>
+        /// <param name="style">L'objet style à ajouter.</param>
         void Add(Style style);
 
+        /// <summary>
+        /// Supprime un style de la liste des styles.
+        /// </summary>
+        /// <param name="style">L'objet style à supprimer.</param>
         void Delete(Style style);
 
+        /// <summary>
+        /// Trouve un style dans la liste des styles en fonction de son identifiant.
+        /// </summary>
+        /// <param name="id">L'identifiant du style à trouver.</param>
+        /// <returns>Le style correspondant à l'identifiant fourni, ou null si aucun style n'est trouvé.</returns>
         Style Find(int id);
 
+        /// <summary>
+        /// Trouve tous les styles dans la liste des styles.
+        /// </summary>
+        /// <returns>Une collection de tous les styles présents dans la liste.</returns>
         IEnumerable<Style> FindAll();
 
+        /// <summary>
+        /// Met à jour un style dans la liste des styles en fonction de son identifiant.
+        /// </summary>
+        /// <param name="style">L'objet style à mettre à jour.</param
         void Update(Style style);
     }
 }
\ No newline at end of file
diff --git a/Webzine.Repository.Contracts/ITitreRepository.cs b/Webzine.Repository.Contracts/ITitreRepository.cs
new file mode 100644
index 0000000..b879b80
--- /dev/null
+++ b/Webzine.Repository.Contracts/ITitreRepository.cs
@@ -0,0 +1,81 @@
+using Webzine.Entity;
+
+namespace Webzine.Repository.Contracts
+{
+    /// <summary>
+    /// Interface qui définit les opérations de base pour la gestion des titres dans une source de données.
+    /// </summary>
+    public interface ITitreRepository
+    {
+        /// <summary>
+        /// Ajoute un titre à la liste des titres.
+        /// </summary>
+        /// <param name="titre">L'objet titre à ajouter.</param>
+        void Add(Titre titre);
+
+        /// <summary>
+        /// Remonte le nombre de titres.
+        /// </summary>
+        /// <returns>Le nombre total de titres présents dans la liste après l'incrémentation du nombre de lectures.</returns>
+        int Count();
+
+        /// <summary>
+        /// Supprime un titre de la liste des titres.
+        /// </summary>
+        /// <param name="titre">L'objet titre à supprimer.</param>
+        void Delete(Titre titre);
+
+        /// <summary>
+        /// Trouve un titre dans la liste des titres en fonction de son identifiant.
+        /// </summary>
+        /// <param name="idTitre">L'identifiant du titre à trouver.</param>
+        /// <returns>Le titre correspondant à l'identifiant fourni, ou null si aucun titre n'est trouvé.</returns>
+        Titre Find(int idTitre);
+
+        /// <summary>
+        /// Recherche les titres dans la liste des titres en fonction de l'offset et de la limite spécifiés, permettant ainsi une pagination des résultats.
+        /// </summary>
+        /// <param name="offset">Le nombre de titres à ignorer avant de commencer à retourner les résultats.</param>
+        /// <param name="limit">Le nombre maximum de titres à retourner.</param>
+        /// <returns>Une collection de titres correspondant au critère de pagination, triée par libellé.</returns>
+        IEnumerable<Titre> FindTitres(int offset, int limit);
+
+        /// <summary>
+        /// Trouve tous les titres dans la liste des titres.
+        /// </summary>
+        /// <returns>Une collection de tous les titres présents dans la liste.</returns>
+        IEnumerable<Titre> FindAll();
+
+        /// <summary>
+        /// Incrémente le nombre de lectures d'un titre donné. Si le titre est null, un message d'avertissement est enregistré dans les logs et aucune action n'est effectuée.
+        /// </summary>
+        /// <param name="titre">L'objet titre dont le nombre de lectures doit être incrémenté.</param>
+        void IncrementNbLectures(Titre titre);
+
+        /// <summary>
+        /// Incrémente le nombre de likes d'un titre donné. Si le titre est null, un message d'avertissement est enregistré dans les logs et aucune action n'est effectuée.
+        /// </summary>
+        /// <param name="titre">L'objet titre dont le nombre de likes doit être incrémenté.</param>
+        void IncrementNbLikes(Titre titre);
+
+        /// <summary>
+        /// Recherche les titres dont le libellé contient le mot spécifié, en ignorant la casse.
+        /// </summary>
+        /// <param name="mot">Le mot à rechercher dans les libellés des titres.</param>
+        /// <returns>Une collection de titres correspondant au critère de recherche, triée par libellé.</returns>
+        IEnumerable<Titre> Search(string mot);
+
+        /// <summary>
+        /// Recherche les titres associés à un style dont le libellé contient la chaîne spécifiée, en ignorant la casse.
+        /// </summary>
+        /// <param name="libelle">Le libellé du style à rechercher dans les titres.</param>
+        /// <returns>Une collection de titres correspondant au critère de recherche, triée par libellé.</returns>
+        IEnumerable<Titre> SearchByStyle(string libelle);
+
+        /// <summary>
+        /// Met à jour un titre dans la liste des titres en fonction de son identifiant. Si aucun titre correspondant à l'identifiant du titre fourni n'est trouvé, un message d'avertissement est enregistré dans les logs et aucune mise à jour n'est effectuée.
+        /// </summary>
+        /// <param name="titre">L'objet titre à mettre à jour.</param>
+        void Update(Titre titre);
+    }
+}
diff --git a/Webzine.Repository.Contracts/ITtitreRepository.cs b/Webzine.Repository.Contracts/ITtitreRepository.cs
deleted file mode 100644
index 0031caa..0000000
--- a/Webzine.Repository.Contracts/ITtitreRepository.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using Webzine.Entity;
-
-namespace Webzine.Repository.Contracts
-{
-    public interface ITitreRepository
-    {
-        void Add(Titre titre);
-
-        int Count();
-
-        void Delete(Titre titre);
-
-        Titre Find(int idTitre);
-
-        IEnumerable<Titre> FindTitres(int offset, int limit);
-
-        IEnumerable<Titre> FindAll();
-
-        void IncrementNbLectures(Titre titre);
-
-        void IncrementNbLikes(Titre titre);
-
-        IEnumerable<Titre> Search(string mot);
-
-        IEnumerable<Titre> SearchByStyle(string libelle);
-
-        void Update(Titre titre);
-    }
-}
diff --git a/Webzine.Repository/DbStyleRepository.cs b/Webzine.Repository/DbStyleRepository.cs
index bf92035..6d8350b 100644
--- a/Webzine.Repository/DbStyleRepository.cs
+++ b/Webzine.Repository/DbStyleRepository.cs
@@ -23,112 +23,158 @@ public class DbStyleRepository : IStyleRepository
     {
         this.logger = logger;
         this.context = context;
-        this.logger.LogDebug(1, "NLog injected into DbStyleRepository");
+        this.logger.LogDebug(1, "NLog injecté dans DbStyleRepository");
     }
 
-    /// <summary>
-    /// Ajoute un style à la base de données.
-    /// </summary>
-    /// <param name="style">L'objet style à ajouter.</param>
+    /// <inheritdoc/>
     public void Add(Style style)
     {
-        this.logger.LogInformation($"Adding new style: {style.Libelle}");
+        try
+        {
+            this.logger.LogInformation("Ajout d'un nouveau style: {Libelle}", style.Libelle);
+            this.logger.LogDebug("Début de l'ajout du style en base de données");
 
-        this.context.Styles.Add(style);
-        this.context.SaveChanges();
+            this.context.Styles.Add(style);
+            this.context.SaveChanges();
 
-        this.logger.LogDebug($"Style added with Id: {style.IdStyle}");
+            this.logger.LogDebug("Style ajouté avec succès avec l'ID: {IdStyle}", style.IdStyle);
+        }
+        catch (DbUpdateException ex)
+        {
+            this.logger.LogError(ex, "Erreur de base de données lors de l'ajout du style: {Libelle}", style.Libelle);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'ajout du style: {Libelle}", style.Libelle);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Supprime un style de la base de données.
-    /// </summary>
-    /// <param name="style">L'objet style à supprimer.</param>
+    /// <inheritdoc/>
     public void Delete(Style style)
     {
-        this.logger.LogInformation($"Deleting style with Id: {style.IdStyle}");
-
-        // Check if style exists
-        var existingStyle = this.context.Styles.Find(style.IdStyle);
-        if (existingStyle == null)
+        try
         {
-            this.logger.LogWarning($"Style with Id {style.IdStyle} not found for deletion");
-            throw new InvalidOperationException($"Style with Id {style.IdStyle} not found.");
+            this.logger.LogInformation("Suppression du style avec l'ID: {IdStyle}", style.IdStyle);
+            this.logger.LogDebug("Vérification de l'existence du style en base de données");
+
+            // Check if style exists
+            var existingStyle = this.context.Styles.Find(style.IdStyle);
+            if (existingStyle == null)
+            {
+                this.logger.LogWarning("Style avec l'ID {IdStyle} non trouvé pour la suppression", style.IdStyle);
+                throw new InvalidOperationException($"Style avec l'ID {style.IdStyle} non trouvé.");
+            }
+
+            this.logger.LogDebug("Style trouvé, suppression en cours");
+            this.context.Styles.Remove(existingStyle);
+            this.context.SaveChanges();
+
+            this.logger.LogDebug("Style supprimé avec succès: {IdStyle}", style.IdStyle);
+        }
+        catch (DbUpdateException ex)
+        {
+            this.logger.LogError(ex, "Erreur de base de données lors de la suppression du style ID: {IdStyle}", style.IdStyle);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la suppression du style ID: {IdStyle}", style.IdStyle);
+            throw;
         }
-
-        this.context.Styles.Remove(existingStyle);
-        this.context.SaveChanges();
-
-        this.logger.LogDebug($"Style deleted: {style.IdStyle}");
     }
 
-    /// <summary>
-    /// Trouve un style dans la base de données en fonction de son identifiant.
-    /// </summary>
-    /// <param name="id">L'identifiant du style à trouver.</param>
-    /// <returns>Le style correspondant à l'identifiant fourni, ou null si aucun style n'est trouvé.</returns>
+    /// <inheritdoc/>
     public Style Find(int id)
     {
-        if (id <= 0)
+        try
         {
-            this.logger.LogWarning($"Tentative de recherche d'un style avec un Id invalide: {id}");
-            return new Style();
+            this.logger.LogDebug("Recherche du style avec l'ID: {Id}", id);
+
+            if (id <= 0)
+            {
+                this.logger.LogWarning("Tentative de recherche d'un style avec un Id invalide: {Id}", id);
+                return new Style();
+            }
+
+            this.logger.LogDebug("Préparation de la requête avec inclusion des titres");
+            var style = this.context.Styles
+                .Include(s => s.Titres)
+                .FirstOrDefault(s => s.IdStyle == id);
+
+            if (style == null)
+            {
+                this.logger.LogWarning("Style avec l'ID {Id} non trouvé", id);
+                style = new Style();
+            }
+            else
+            {
+                this.logger.LogDebug("Style trouvé: {Libelle}", style.Libelle);
+            }
+
+            return style;
         }
-
-        this.logger.LogDebug($"Finding style with Id: {id}");
-
-        var style = this.context.Styles
-            .Include(s => s.Titres)
-            .FirstOrDefault(s => s.IdStyle == id);
-
-        if (style == null)
+        catch (Exception ex)
         {
-            this.logger.LogWarning($"Style with Id {id} not found");
-            style = new Style();
+            this.logger.LogError(ex, "Erreur lors de la recherche du style avec l'ID: {Id}", id);
+            throw;
         }
-        else
-        {
-            this.logger.LogDebug($"Found style: {style.Libelle}");
-        }
-
-        return style;
     }
 
-    /// <summary>
-    /// Trouve tous les styles dans la base de données.
-    /// </summary>
-    /// <returns>Une collection de tous les styles présents dans la base de données.</returns>
+    /// <inheritdoc/>
     public IEnumerable<Style> FindAll()
     {
-        this.logger.LogDebug("Finding all styles");
+        try
+        {
+            this.logger.LogDebug("Récupération de tous les styles");
+            this.logger.LogDebug("Tri des styles par libellé");
 
-        var styles = this.context.Styles
-            .OrderBy(s => s.Libelle)
-            .ToList();
+            var styles = this.context.Styles
+                .OrderBy(s => s.Libelle)
+                .ToList();
 
-        this.logger.LogDebug($"Found {styles.Count} total styles");
-        return styles;
+            this.logger.LogDebug("{Count} styles récupérés", styles.Count);
+            return styles;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la récupération de tous les styles");
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Met à jour les informations d'un style dans la base de données.
-    /// </summary>
-    /// <param name="style">L'objet style avec les informations mises à jour.</param>
+    /// <inheritdoc/>
     public void Update(Style style)
     {
-        this.logger.LogInformation($"Updating style with Id: {style.IdStyle}");
-
-        var existingStyle = this.context.Styles.Find(style.IdStyle);
-        if (existingStyle == null)
+        try
         {
-            this.logger.LogWarning($"Style with Id {style.IdStyle} not found for update");
-            throw new InvalidOperationException($"Style with Id {style.IdStyle} not found.");
+            this.logger.LogInformation("Mise à jour du style avec l'ID: {IdStyle}", style.IdStyle);
+            this.logger.LogDebug("Recherche du style en base de données");
+
+            var existingStyle = this.context.Styles.Find(style.IdStyle);
+            if (existingStyle == null)
+            {
+                this.logger.LogWarning("Style avec l'ID {IdStyle} non trouvé pour la mise à jour", style.IdStyle);
+                throw new InvalidOperationException($"Style avec l'ID {style.IdStyle} non trouvé.");
+            }
+
+            // Update properties
+            this.logger.LogDebug("Style trouvé, mise à jour des propriétés");
+            existingStyle.Libelle = style.Libelle;
+
+            this.context.SaveChanges();
+            this.logger.LogDebug("Style mis à jour avec succès: {IdStyle}", style.IdStyle);
+        }
+        catch (DbUpdateException ex)
+        {
+            this.logger.LogError(ex, "Erreur de base de données lors de la mise à jour du style ID: {IdStyle}", style.IdStyle);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la mise à jour du style ID: {IdStyle}", style.IdStyle);
+            throw;
         }
-
-        // Update properties
-        existingStyle.Libelle = style.Libelle;
-
-        this.context.SaveChanges();
-        this.logger.LogDebug($"Style updated: {style.IdStyle}");
     }
 }
\ No newline at end of file
diff --git a/Webzine.Repository/DbTitreRepository.cs b/Webzine.Repository/DbTitreRepository.cs
index 221307e..0b0c260 100644
--- a/Webzine.Repository/DbTitreRepository.cs
+++ b/Webzine.Repository/DbTitreRepository.cs
@@ -23,211 +23,312 @@ public class DbTitreRepository : ITitreRepository
     {
         this.logger = logger;
         this.context = context;
-        this.logger.LogDebug(1, "NLog injected into DbTitreRepository");
+        this.logger.LogDebug(1, "NLog injecté dans DbTitreRepository");
     }
 
-    /// <summary>
-    /// Ajoute un titre à la base de données.
-    /// </summary>
-    /// <param name="titre">L'objet titre à ajouter.</param>
+    /// <inheritdoc/>
     public void Add(Titre titre)
     {
-        this.logger.LogInformation($"Adding new titre: {titre.Libelle}");
-        this.context.Titres.Add(titre);
-        this.context.SaveChanges();
-        this.logger.LogDebug($"Titre added with Id: {titre.IdTitre}");
+        try
+        {
+            this.logger.LogInformation("Ajout d'un nouveau titre: {Libelle}", titre.Libelle);
+            this.logger.LogDebug("Début de l'ajout du titre en base de données");
+
+            this.context.Titres.Add(titre);
+            this.context.SaveChanges();
+
+            this.logger.LogDebug("Titre ajouté avec succès avec l'ID: {IdTitre}", titre.IdTitre);
+        }
+        catch (DbUpdateException ex)
+        {
+            this.logger.LogError(ex, "Erreur de base de données lors de l'ajout du titre: {Libelle}", titre.Libelle);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'ajout du titre: {Libelle}", titre.Libelle);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Remonte le nombre de titres.
-    /// </summary>
-    /// <returns>Le nombre total de titres présents dans la base de données.</returns>
+    /// <inheritdoc/>
     public int Count()
     {
-        var count = this.context.Titres.Count();
-        this.logger.LogDebug($"Total titres count: {count}");
-        return count;
+        try
+        {
+            this.logger.LogDebug("Comptage des titres en base de données");
+            var count = this.context.Titres.Count();
+            this.logger.LogDebug("Nombre total de titres: {Count}", count);
+            return count;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors du comptage des titres");
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Supprime un titre de la base de données.
-    /// </summary>
-    /// <param name="titre">L'objet titre à supprimer.</param>
+    /// <inheritdoc/>
     public void Delete(Titre titre)
     {
-        this.logger.LogInformation($"Deleting titre with Id: {titre.IdTitre}");
-        this.context.Titres.Remove(titre);
-        this.context.SaveChanges();
-        this.logger.LogDebug($"Titre deleted: {titre.IdTitre}");
+        try
+        {
+            this.logger.LogInformation("Suppression du titre avec l'ID: {IdTitre}", titre.IdTitre);
+            this.logger.LogDebug("Début de la suppression du titre en base de données");
+
+            this.context.Titres.Remove(titre);
+            this.context.SaveChanges();
+
+            this.logger.LogDebug("Titre supprimé avec succès: {IdTitre}", titre.IdTitre);
+        }
+        catch (DbUpdateException ex)
+        {
+            this.logger.LogError(ex, "Erreur de base de données lors de la suppression du titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la suppression du titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Recherche les titres dans la base de données en fonction de l'offset et de la limite spécifiés, permettant ainsi une pagination des résultats.
-    /// </summary>
-    /// <param name="offset">L'offset à partir duquel commencer la recherche des titres.</param>
-    /// <param name="limit">Le nombre maximum de titres à retourner dans les résultats de la recherche.</param>
-    /// <returns>Une collection de titres correspondant au critère de recherche, triée par libellé.</returns>
+    /// <inheritdoc/>
     public IEnumerable<Titre> FindTitres(int offset, int limit)
     {
-        this.logger.LogDebug($"Finding titres with offset: {offset}, limit: {limit}");
+        try
+        {
+            this.logger.LogDebug("Recherche des titres avec offset: {Offset}, limit: {Limit}", offset, limit);
+            this.logger.LogDebug("Préparation de la requête avec les inclusions Artiste et Styles");
 
-        var titres = this.context.Titres
-            .Include(t => t.Artiste)
-            .Include(t => t.Styles)
-            .OrderBy(t => t.Libelle)
-            .Skip(offset)
-            .Take(limit)
-            .ToList();
+            var titres = this.context.Titres
+                .Include(t => t.Artiste)
+                .Include(t => t.Styles)
+                .OrderBy(t => t.Libelle)
+                .Skip(offset)
+                .Take(limit)
+                .ToList();
 
-        this.logger.LogDebug($"Found {titres.Count} titres");
-        return titres;
+            this.logger.LogDebug("{Count} titres trouvés", titres.Count);
+            return titres;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche des titres avec offset: {Offset}, limit: {Limit}", offset, limit);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Incrémente le nombre de lectures d'un titre dans la base de données.
-    /// </summary>
-    /// <param name="titre">L'objet titre pour lequel le nombre de lectures doit être incrémenté.</param>
+    /// <inheritdoc/>
     public void IncrementNbLectures(Titre titre)
     {
-        this.logger.LogInformation($"Incrementing lecture count for titre Id: {titre.IdTitre}");
+        try
+        {
+            this.logger.LogInformation("Incrémentation du nombre de lectures pour le titre ID: {IdTitre}", titre.IdTitre);
+            this.logger.LogDebug("Recherche du titre en base de données");
 
-        var existingTitre = this.context.Titres.Find(titre.IdTitre);
-        if (existingTitre != null)
-        {
-            existingTitre.NbLectures++;
-            this.context.SaveChanges();
-            this.logger.LogDebug($"New lecture count: {existingTitre.NbLectures}");
+            var existingTitre = this.context.Titres.Find(titre.IdTitre);
+            if (existingTitre != null)
+            {
+                this.logger.LogDebug("Titre trouvé, incrémentation du compteur de lectures");
+                existingTitre.NbLectures++;
+                this.context.SaveChanges();
+                this.logger.LogDebug("Nouveau nombre de lectures: {NbLectures}", existingTitre.NbLectures);
+            }
+            else
+            {
+                this.logger.LogWarning("Titre avec l'ID {IdTitre} non trouvé pour l'incrémentation des lectures", titre.IdTitre);
+            }
         }
-        else
+        catch (DbUpdateException ex)
         {
-            this.logger.LogWarning($"Titre with Id {titre.IdTitre} not found for incrementing lectures");
+            this.logger.LogError(ex, "Erreur de base de données lors de l'incrémentation des lectures pour le titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'incrémentation des lectures pour le titre ID: {IdTitre}", titre.IdTitre);
+            throw;
         }
     }
 
-    /// <summary>
-    /// Incrémente le nombre de likes d'un titre dans la base de données.
-    /// </summary>
-    /// <param name="titre">L'objet titre pour lequel le nombre de likes doit être incrémenté.</param>
+    /// <inheritdoc/>
     public void IncrementNbLikes(Titre titre)
     {
-        this.logger.LogInformation($"Incrementing like count for titre Id: {titre.IdTitre}");
+        try
+        {
+            this.logger.LogInformation("Incrémentation du nombre de likes pour le titre ID: {IdTitre}", titre.IdTitre);
+            this.logger.LogDebug("Recherche du titre en base de données");
 
-        var existingTitre = this.context.Titres.Find(titre.IdTitre);
-        if (existingTitre != null)
-        {
-            existingTitre.NbLikes++;
-            this.context.SaveChanges();
-            this.logger.LogDebug($"New like count: {existingTitre.NbLikes}");
+            var existingTitre = this.context.Titres.Find(titre.IdTitre);
+            if (existingTitre != null)
+            {
+                this.logger.LogDebug("Titre trouvé, incrémentation du compteur de likes");
+                existingTitre.NbLikes++;
+                this.context.SaveChanges();
+                this.logger.LogDebug("Nouveau nombre de likes: {NbLikes}", existingTitre.NbLikes);
+            }
+            else
+            {
+                this.logger.LogWarning("Titre avec l'ID {IdTitre} non trouvé pour l'incrémentation des likes", titre.IdTitre);
+            }
         }
-        else
+        catch (DbUpdateException ex)
         {
-            this.logger.LogWarning($"Titre with Id {titre.IdTitre} not found for incrementing likes");
+            this.logger.LogError(ex, "Erreur de base de données lors de l'incrémentation des likes pour le titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'incrémentation des likes pour le titre ID: {IdTitre}", titre.IdTitre);
+            throw;
         }
     }
 
-    /// <summary>
-    /// Met à jour les informations d'un titre dans la base de données en fonction de son identifiant.
-    /// </summary>
-    /// <param name="titre">L'objet titre à mettre à jour.</param>
+    /// <inheritdoc/>
     public void Update(Titre titre)
     {
-        this.logger.LogInformation($"Updating titre with Id: {titre.IdTitre}");
-
-        var existingTitre = this.context.Titres.Find(titre.IdTitre);
-        if (existingTitre != null)
+        try
         {
-            this.context.Entry(existingTitre).CurrentValues.SetValues(titre);
+            this.logger.LogInformation("Mise à jour du titre avec l'ID: {IdTitre}", titre.IdTitre);
+            this.logger.LogDebug("Début de la mise à jour du titre en base de données");
 
-            // Handle many-to-many relationships
-            this.context.Entry(existingTitre).Collection(t => t.Styles).Load();
-            existingTitre.Styles.Clear();
-            foreach (var style in titre.Styles)
+            var existingTitre = this.context.Titres.Find(titre.IdTitre);
+            if (existingTitre != null)
             {
-                existingTitre.Styles.Add(style);
-            }
+                this.logger.LogDebug("Titre trouvé, mise à jour des propriétés");
+                this.context.Entry(existingTitre).CurrentValues.SetValues(titre);
 
-            this.context.SaveChanges();
-            this.logger.LogDebug($"Titre updated: {titre.IdTitre}");
+                // Handle many-to-many relationships
+                this.logger.LogDebug("Mise à jour des relations many-to-many (Styles)");
+                this.context.Entry(existingTitre).Collection(t => t.Styles).Load();
+                existingTitre.Styles.Clear();
+                foreach (var style in titre.Styles)
+                {
+                    existingTitre.Styles.Add(style);
+                }
+
+                this.context.SaveChanges();
+                this.logger.LogDebug("Titre mis à jour avec succès: {IdTitre}", titre.IdTitre);
+            }
+            else
+            {
+                this.logger.LogWarning("Titre avec l'ID {IdTitre} non trouvé pour la mise à jour", titre.IdTitre);
+                throw new InvalidOperationException($"Titre avec l'ID {titre.IdTitre} non trouvé.");
+            }
         }
-        else
+        catch (DbUpdateException ex)
         {
-            this.logger.LogWarning($"Titre with Id {titre.IdTitre} not found for update");
+            this.logger.LogError(ex, "Erreur de base de données lors de la mise à jour du titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la mise à jour du titre ID: {IdTitre}", titre.IdTitre);
+            throw;
         }
     }
 
-    /// <summary>
-    /// Recherche les titres dont le libellé contient le mot spécifié, en ignorant la casse.
-    /// </summary>
-    /// <param name="mot">Le mot à rechercher dans les libellés des titres.</param>
-    /// <returns>Une collection de titres correspondant au critère de recherche, triée par libellé.</returns>
+    /// <inheritdoc/>
     public IEnumerable<Titre> Search(string mot)
     {
-        this.logger.LogInformation($"Searching titres with keyword: {mot}");
+        try
+        {
+            this.logger.LogInformation("Recherche des titres avec le mot-clé: {Mot}", mot);
+            this.logger.LogDebug("Préparation de la requête de recherche avec les inclusions");
 
-        var titres = this.context.Titres
-            .Include(t => t.Artiste)
-            .Include(t => t.Styles)
-            .Where(t => t.Libelle.ToLower().Contains(mot.ToLower()))
-            .OrderBy(t => t.Libelle)
-            .ToList();
+            var titres = this.context.Titres
+                .Include(t => t.Artiste)
+                .Include(t => t.Styles)
+                .Where(t => t.Libelle.ToLower().Contains(mot.ToLower()))
+                .OrderBy(t => t.Libelle)
+                .ToList();
 
-        this.logger.LogDebug($"Found {titres.Count} titres matching '{mot}'");
-        return titres;
+            this.logger.LogDebug("{Count} titres trouvés correspondant à '{Mot}'", titres.Count, mot);
+            return titres;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche des titres avec le mot-clé: {Mot}", mot);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Trouve un titre dans la base de données en fonction de son identifiant.
-    /// </summary>
-    /// <param name="idTitre">L'identifiant du titre à trouver.</param>
-    /// <returns>Le titre correspondant à l'identifiant fourni, ou null si aucun titre n'est trouvé.</returns>
+    /// <inheritdoc/>
     public Titre Find(int idTitre)
     {
-        this.logger.LogDebug($"Finding titre with Id: {idTitre}");
+        try
+        {
+            this.logger.LogDebug("Recherche du titre avec l'ID: {IdTitre}", idTitre);
+            this.logger.LogDebug("Préparation de la requête avec les inclusions Artiste, Styles et Commentaires");
 
-        var titre = this.context.Titres
-            .Include(t => t.Artiste)
-            .Include(t => t.Styles)
-            .Include(t => t.Commentaires)
-            .First(t => t.IdTitre == idTitre);
+            var titre = this.context.Titres
+                .Include(t => t.Artiste)
+                .Include(t => t.Styles)
+                .Include(t => t.Commentaires)
+                .First(t => t.IdTitre == idTitre);
 
-        return titre;
+            this.logger.LogDebug("Titre trouvé: {Libelle}", titre.Libelle);
+            return titre;
+        }
+        catch (InvalidOperationException ex)
+        {
+            this.logger.LogWarning(ex, "Aucun titre trouvé avec l'ID: {IdTitre}", idTitre);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche du titre avec l'ID: {IdTitre}", idTitre);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Trouve tous les titres dans la base de données.
-    /// </summary>
-    /// <returns>Une collection de tous les titres présents dans la base de données.</returns>
+    /// <inheritdoc/>
     public IEnumerable<Titre> FindAll()
     {
-        this.logger.LogDebug("Finding all titres");
+        try
+        {
+            this.logger.LogDebug("Récupération de tous les titres");
+            this.logger.LogDebug("Préparation de la requête avec les inclusions Artiste et Styles");
 
-        var titres = this.context.Titres
-            .Include(t => t.Artiste)
-            .Include(t => t.Styles)
-            .OrderBy(t => t.Libelle)
-            .ToList();
+            var titres = this.context.Titres
+                .Include(t => t.Artiste)
+                .Include(t => t.Styles)
+                .OrderBy(t => t.Libelle)
+                .ToList();
 
-        this.logger.LogDebug($"Found {titres.Count} total titres");
-        return titres;
+            this.logger.LogDebug("{Count} titres récupérés", titres.Count);
+            return titres;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la récupération de tous les titres");
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Recherche les titres associés à un style dont le libellé correspond à celui spécifié, en ignorant la casse.
-    /// </summary>
-    /// <param name="libelle">Le libellé du style à rechercher.</param>
-    /// <returns>Une collection de titres correspondant au critère de recherche, triée par libellé.</returns>
+    /// <inheritdoc/>
     public IEnumerable<Titre> SearchByStyle(string libelle)
     {
-        this.logger.LogInformation($"Searching titres by style: {libelle}");
+        try
+        {
+            this.logger.LogInformation("Recherche des titres par style: {Libelle}", libelle);
+            this.logger.LogDebug("Préparation de la requête de recherche par style");
 
-        var titres = this.context.Titres
-            .Include(t => t.Artiste)
-            .Include(t => t.Styles)
-            .Where(t => t.Styles.Any(s => s.Libelle.ToLower() == libelle.ToLower()))
-            .OrderBy(t => t.Libelle)
-            .ToList();
+            var titres = this.context.Titres
+                .Include(t => t.Artiste)
+                .Include(t => t.Styles)
+                .Where(t => t.Styles.Any(s => s.Libelle.ToLower() == libelle.ToLower()))
+                .OrderBy(t => t.Libelle)
+                .ToList();
 
-        this.logger.LogDebug($"Found {titres.Count} titres for style '{libelle}'");
-        return titres;
+            this.logger.LogDebug("{Count} titres trouvés pour le style '{Libelle}'", titres.Count, libelle);
+            return titres;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche des titres par style: {Libelle}", libelle);
+            throw;
+        }
     }
 }
\ No newline at end of file
diff --git a/Webzine.Repository/LocalStyleRepository.cs b/Webzine.Repository/LocalStyleRepository.cs
index e27a102..6a3bde6 100644
--- a/Webzine.Repository/LocalStyleRepository.cs
+++ b/Webzine.Repository/LocalStyleRepository.cs
@@ -21,70 +21,115 @@ public class LocalStyleRepository : IStyleRepository
     {
         this.logger = logger;
         this.styles = styles;
-        this.logger.LogDebug(1, "NLog injected into LocalEntityRepository");
+        this.logger.LogDebug(1, "NLog injecté dans LocalStyleRepository");
     }
 
-    /// <summary>
-    /// Ajoute un style à la liste des styles.
-    /// </summary>
-    /// <param name="style">L'objet style à ajouter.</param>
+    /// <inheritdoc/>
     public void Add(Style style)
     {
-        this.styles.Add(style);
+        try
+        {
+            this.logger.LogDebug("Ajout du style: {Libelle}", style.Libelle);
+            this.styles.Add(style);
+            this.logger.LogDebug("Style ajouté avec succès, ID: {IdStyle}", style.IdStyle);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'ajout du style: {Libelle}", style.Libelle);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Supprime un style de la liste des styles.
-    /// </summary>
-    /// <param name="style">L'objet style à supprimer.</param>
+    /// <inheritdoc/>
     public void Delete(Style style)
     {
-        if (!this.styles.Contains(style))
+        try
         {
-            this.logger.LogWarning("Le style avec l'identifiant {IdStyle} n'existe pas dans la liste.", style.IdStyle);
-        }
+            this.logger.LogDebug("Suppression du style ID: {IdStyle}", style.IdStyle);
 
-        this.styles.Remove(style);
+            if (!this.styles.Contains(style))
+            {
+                this.logger.LogWarning("Le style avec l'identifiant {IdStyle} n'existe pas dans la liste.", style.IdStyle);
+            }
+
+            this.styles.Remove(style);
+            this.logger.LogDebug("Style supprimé avec succès, ID: {IdStyle}", style.IdStyle);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la suppression du style ID: {IdStyle}", style.IdStyle);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Trouve un style dans la liste des styles en fonction de son identifiant.
-    /// </summary>
-    /// <param name="id">L'identifiant du style à trouver.</param>
-    /// <returns>Le style correspondant à l'identifiant fourni, ou null si aucun style n'est trouvé.</returns>
+    /// <inheritdoc/>
     public Style Find(int id)
     {
-        if (id <= 0)
+        try
         {
-            this.logger.LogWarning("Le style fourni est null.");
-        }
+            this.logger.LogDebug("Recherche du style avec ID: {Id}", id);
 
-        Style style = this.styles.First(s => s.IdStyle == id);
-        return style;
+            if (id <= 0)
+            {
+                this.logger.LogWarning("Tentative de recherche d'un style avec un Id invalide: {Id}", id);
+                return new Style();
+            }
+
+            Style style = this.styles.First(s => s.IdStyle == id);
+            this.logger.LogDebug("Style trouvé: {Libelle}", style.Libelle);
+            return style;
+        }
+        catch (InvalidOperationException ex)
+        {
+            this.logger.LogWarning(ex, "Aucun style trouvé avec l'ID: {Id}", id);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche du style avec ID: {Id}", id);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Trouve tous les styles dans la liste des styles.
-    /// </summary>
-    /// <returns>Une collection de tous les styles présents dans la liste.</returns>
+    /// <inheritdoc/>
     public IEnumerable<Style> FindAll()
     {
-        return this.styles;
+        try
+        {
+            this.logger.LogDebug("Récupération de tous les styles");
+            var result = this.styles;
+            this.logger.LogDebug("{Count} styles récupérés", result.Count);
+            return result;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la récupération de tous les styles");
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Met à jour un style dans la liste des styles en fonction de son identifiant.
-    /// </summary>
-    /// <param name="style">L'objet style à mettre à jour.</param>
+    /// <inheritdoc/>
     public void Update(Style style)
     {
-        int index = this.styles.FindIndex(s => s.IdStyle == style.IdStyle);
-
-        if (index == -1)
+        try
         {
-            this.logger.LogWarning("Aucun style trouvé avec l'identifiant {IdStyle}.", style.IdStyle);
-        }
+            this.logger.LogDebug("Mise à jour du style ID: {IdStyle}", style.IdStyle);
 
-        this.styles[index] = style;
+            int index = this.styles.FindIndex(s => s.IdStyle == style.IdStyle);
+
+            if (index == -1)
+            {
+                this.logger.LogWarning("Aucun style trouvé avec l'identifiant {IdStyle}.", style.IdStyle);
+                throw new InvalidOperationException($"Aucun style trouvé avec l'identifiant {style.IdStyle}.");
+            }
+
+            this.styles[index] = style;
+            this.logger.LogDebug("Style mis à jour avec succès, ID: {IdStyle}", style.IdStyle);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la mise à jour du style ID: {IdStyle}", style.IdStyle);
+            throw;
+        }
     }
 }
\ No newline at end of file
diff --git a/Webzine.Repository/LocalTitreRepository.cs b/Webzine.Repository/LocalTitreRepository.cs
index acc4602..057b66e 100644
--- a/Webzine.Repository/LocalTitreRepository.cs
+++ b/Webzine.Repository/LocalTitreRepository.cs
@@ -21,169 +21,254 @@ public class LocalTitreRepository : ITitreRepository
     {
         this.logger = logger;
         this.titres = titres;
-        this.logger.LogDebug(1, "NLog injected into LocalTitreRepository");
+        this.logger.LogDebug(1, "NLog injecté dans LocalTitreRepository");
     }
 
-    /// <summary>
-    /// Ajoute un titre à la liste des titres.
-    /// </summary>
-    /// <param name="titre">L'objet titre à ajouter.</param>
+    /// <inheritdoc/>
     public void Add(Titre titre)
     {
-        this.titres.Add(titre);
+        try
+        {
+            this.logger.LogDebug("Ajout du titre: {Libelle}", titre.Libelle);
+            this.titres.Add(titre);
+            this.logger.LogDebug("Titre ajouté avec succès, ID: {IdTitre}", titre.IdTitre);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'ajout du titre: {Libelle}", titre.Libelle);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Remonte le nombre de titres.
-    /// </summary>
-    /// <returns>Le nombre total de titres présents dans la liste après l'incrémentation du nombre de lectures.</returns>
+    /// <inheritdoc/>
     public int Count()
     {
-        return this.titres.Count;
+        try
+        {
+            var count = this.titres.Count;
+            this.logger.LogDebug("Nombre total de titres: {Count}", count);
+            return count;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors du comptage des titres");
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Supprime un titre de la liste des titres.
-    /// </summary>
-    /// <param name="titre">L'objet titre à supprimer.</param>
+    /// <inheritdoc/>
     public void Delete(Titre titre)
     {
-        if (!this.titres.Contains(titre))
+        try
         {
-            this.logger.LogWarning("Le titre avec l'identifiant {IdTitre} n'existe pas dans la liste.", titre.IdTitre);
-        }
+            this.logger.LogDebug("Suppression du titre ID: {IdTitre}", titre.IdTitre);
 
-        this.titres.Remove(titre);
+            if (!this.titres.Contains(titre))
+            {
+                this.logger.LogWarning("Le titre avec l'identifiant {IdTitre} n'existe pas dans la liste.", titre.IdTitre);
+            }
+
+            this.titres.Remove(titre);
+            this.logger.LogDebug("Titre supprimé avec succès, ID: {IdTitre}", titre.IdTitre);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la suppression du titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Recherche les titres dans la liste des titres en fonction de l'offset et de la limite spécifiés, permettant ainsi une pagination des résultats.
-    /// </summary>
-    /// <param name="offset">Le nombre de titres à ignorer avant de commencer à retourner les résultats.</param>
-    /// <param name="limit">Le nombre maximum de titres à retourner.</param>
-    /// <returns>Une collection de titres correspondant au critère de pagination, triée par libellé.</returns>
+    /// <inheritdoc/>
     public IEnumerable<Titre> FindTitres(int offset, int limit)
     {
-        if (offset < 0 || limit <= 0)
+        try
         {
-            this.logger.LogWarning("FindTitres called with invalid offset {Offset} or limit {Limit}.", offset, limit);
-            return Enumerable.Empty<Titre>();
-        }
+            this.logger.LogDebug("Recherche des titres avec offset: {Offset}, limit: {Limit}", offset, limit);
 
-        return this.titres.Skip(offset).Take(limit).ToList();
+            if (offset < 0 || limit <= 0)
+            {
+                this.logger.LogWarning("FindTitres appelé avec offset {Offset} ou limit {Limit} invalide.", offset, limit);
+                return Enumerable.Empty<Titre>();
+            }
+
+            var result = this.titres.Skip(offset).Take(limit).ToList();
+            this.logger.LogDebug("{Count} titres trouvés", result.Count);
+            return result;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche des titres avec offset: {Offset}, limit: {Limit}", offset, limit);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Incrémente le nombre de lectures d'un titre donné. Si le titre est null, un message d'avertissement est enregistré dans les logs et aucune action n'est effectuée.
-    /// </summary>
-    /// <param name="titre">L'objet titre dont le nombre de lectures doit être incrémenté.</param>
+    /// <inheritdoc/>
     public void IncrementNbLectures(Titre titre)
     {
-        titre.NbLectures++;
+        try
+        {
+            this.logger.LogDebug("Incrémentation du nombre de lectures pour le titre ID: {IdTitre}", titre.IdTitre);
+            titre.NbLectures++;
+            this.logger.LogDebug("Nouveau nombre de lectures: {NbLectures}", titre.NbLectures);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'incrémentation des lectures pour le titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Incrémente le nombre de likes d'un titre donné. Si le titre est null, un message d'avertissement est enregistré dans les logs et aucune action n'est effectuée.
-    /// </summary>
-    /// <param name="titre">L'objet titre dont le nombre de likes doit être incrémenté.</param>
+    /// <inheritdoc/>
     public void IncrementNbLikes(Titre titre)
     {
-        titre.NbLikes++;
+        try
+        {
+            this.logger.LogDebug("Incrémentation du nombre de likes pour le titre ID: {IdTitre}", titre.IdTitre);
+            titre.NbLikes++;
+            this.logger.LogDebug("Nouveau nombre de likes: {NbLikes}", titre.NbLikes);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'incrémentation des likes pour le titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Recherche les titres dont le libellé contient le mot spécifié, en ignorant la casse.
-    /// </summary>
-    /// <param name="mot">Le mot à rechercher dans les libellés des titres.</param>
-    /// <returns>Une collection de titres correspondant au critère de recherche, triée par libellé.</returns>
+    /// <inheritdoc/>
     public IEnumerable<Titre> Search(string mot)
     {
-        if (string.IsNullOrWhiteSpace(mot))
+        try
         {
-            this.logger.LogWarning("Search called with an empty or whitespace string.");
-            return Enumerable.Empty<Titre>();
+            this.logger.LogDebug("Recherche de titres avec le mot-clé: {Mot}", mot);
+
+            if (string.IsNullOrWhiteSpace(mot))
+            {
+                this.logger.LogWarning("Search appelé avec une chaîne vide ou contenant uniquement des espaces.");
+                return Enumerable.Empty<Titre>();
+            }
+
+            IEnumerable<Titre> list = this.titres
+                .Where(t => !string.IsNullOrWhiteSpace(t.Libelle)
+                            && t.Libelle.Contains(mot, StringComparison.OrdinalIgnoreCase))
+                .OrderBy(t => t.Libelle)
+                .ToList();
+
+            if (!list.Any())
+            {
+                this.logger.LogInformation("Aucun titre trouvé correspondant au terme de recherche '{Mot}'.", mot);
+            }
+            else
+            {
+                this.logger.LogDebug("{Count} titres trouvés pour le mot-clé '{Mot}'", list.Count(), mot);
+            }
+
+            return list;
         }
-
-        IEnumerable<Titre> list = this.titres
-            .Where(t => !string.IsNullOrWhiteSpace(t.Libelle)
-                        && t.Libelle.Contains(mot, StringComparison.OrdinalIgnoreCase))
-            .OrderBy(t => t.Libelle)
-            .ToList();
-
-        if (!list.Any())
+        catch (Exception ex)
         {
-            this.logger.LogInformation("No titres found matching the search term '{Mot}'.", mot);
+            this.logger.LogError(ex, "Erreur lors de la recherche des titres avec le mot-clé: {Mot}", mot);
+            throw;
         }
-
-        return list;
     }
 
-    /// <summary>
-    /// Trouve un titre dans la liste des titres en fonction de son identifiant.
-    /// </summary>
-    /// <param name="idTitre">L'identifiant du titre à trouver.</param>
-    /// <returns>Le titre correspondant à l'identifiant fourni, ou null si aucun titre n'est trouvé.</returns>
-    public Titre? Find(int idTitre)
+    /// <inheritdoc/>
+    public Titre Find(int idTitre)
     {
-        Titre? titre = titres.FirstOrDefault(t => t.IdTitre == idTitre);
-
-        if (titre == null)
+        try
         {
-            this.logger.LogInformation("No titre found with IdTitre {IdTitre}.", idTitre);
+            this.logger.LogDebug("Recherche du titre avec ID: {IdTitre}", idTitre);
+            Titre titre = this.titres.First(t => t.IdTitre == idTitre);
+            this.logger.LogDebug("Titre trouvé: {Libelle}", titre.Libelle);
+            return titre;
+        }
+        catch (InvalidOperationException ex)
+        {
+            this.logger.LogWarning(ex, "Aucun titre trouvé avec l'ID: {IdTitre}", idTitre);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche du titre avec ID: {IdTitre}", idTitre);
+            throw;
         }
-
-        return titre;
     }
 
-    /// <summary>
-    /// Trouve tous les titres dans la liste des titres.
-    /// </summary>
-    /// <returns>Une collection de tous les titres présents dans la liste.</returns>
+    /// <inheritdoc/>
     public IEnumerable<Titre> FindAll()
     {
-        return this.titres;
+        try
+        {
+            this.logger.LogDebug("Récupération de tous les titres");
+            var result = this.titres;
+            this.logger.LogDebug("{Count} titres récupérés", result.Count);
+            return result;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la récupération de tous les titres");
+            throw;
+        }
     }
 
-    /// <summary>
-    /// Recherche les titres associés à un style dont le libellé contient la chaîne spécifiée, en ignorant la casse.
-    /// </summary>
-    /// <param name="libelle">Le libellé du style à rechercher dans les titres.</param>
-    /// <returns>Une collection de titres correspondant au critère de recherche, triée par libellé.</returns>
+    /// <inheritdoc/>
     public IEnumerable<Titre> SearchByStyle(string libelle)
     {
-        if (string.IsNullOrWhiteSpace(libelle))
+        try
         {
-            this.logger.LogWarning("SearchByStyle called with an empty or whitespace string.");
-            return Enumerable.Empty<Titre>();
+            this.logger.LogDebug("Recherche des titres par style: {Libelle}", libelle);
+
+            if (string.IsNullOrWhiteSpace(libelle))
+            {
+                this.logger.LogWarning("SearchByStyle appelé avec une chaîne vide ou contenant uniquement des espaces.");
+                return Enumerable.Empty<Titre>();
+            }
+
+            IEnumerable<Titre> list = this.titres
+                .Where(t => t.Styles.Any(s => !string.IsNullOrWhiteSpace(s.Libelle)
+                                                && s.Libelle.Contains(libelle, StringComparison.OrdinalIgnoreCase)))
+                .OrderBy(t => t.Libelle)
+                .ToList();
+
+            if (!list.Any())
+            {
+                this.logger.LogInformation("Aucun titre trouvé correspondant au style '{Libelle}'.", libelle);
+            }
+            else
+            {
+                this.logger.LogDebug("{Count} titres trouvés pour le style '{Libelle}'", list.Count(), libelle);
+            }
+
+            return list;
         }
-
-        IEnumerable<Titre> list = this.titres
-            .Where(t => t.Styles.Any(s => !string.IsNullOrWhiteSpace(s.Libelle)
-                                            && s.Libelle.Contains(libelle, StringComparison.OrdinalIgnoreCase)))
-            .OrderBy(t => t.Libelle)
-            .ToList();
-
-        if (!list.Any())
+        catch (Exception ex)
         {
-            this.logger.LogInformation("No titres found matching the style '{Libelle}'.", libelle);
+            this.logger.LogError(ex, "Erreur lors de la recherche des titres par style: {Libelle}", libelle);
+            throw;
         }
-
-        return list;
     }
 
-    /// <summary>
-    /// Met à jour un titre dans la liste des titres en fonction de son identifiant. Si aucun titre correspondant à l'identifiant du titre fourni n'est trouvé, un message d'avertissement est enregistré dans les logs et aucune mise à jour n'est effectuée.
-    /// </summary>
-    /// <param name="titre">L'objet titre à mettre à jour.</param>
+    /// <inheritdoc/>
     public void Update(Titre titre)
     {
-        int index = this.titres.FindIndex(t => t.IdTitre == titre.IdTitre);
-
-        if (index == -1)
+        try
         {
-            this.logger.LogWarning("Aucun titre trouvé avec l'identifiant {IdTitre}.", titre.IdTitre);
-        }
+            this.logger.LogDebug("Mise à jour du titre ID: {IdTitre}", titre.IdTitre);
 
-        this.titres[index] = titre;
+            int index = this.titres.FindIndex(t => t.IdTitre == titre.IdTitre);
+
+            if (index == -1)
+            {
+                this.logger.LogWarning("Aucun titre trouvé avec l'identifiant {IdTitre}.", titre.IdTitre);
+                throw new InvalidOperationException($"Aucun titre trouvé avec l'identifiant {titre.IdTitre}.");
+            }
+
+            this.titres[index] = titre;
+            this.logger.LogDebug("Titre mis à jour avec succès, ID: {IdTitre}", titre.IdTitre);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la mise à jour du titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
     }
 }
\ No newline at end of file