Code Review

le Code Review est une étape cruciale pour garantir la qualité, la maintenabilité et la performance du code. Les étapes principales d’un bon processus de revue de code :

---

1. Préparation du Code Review

Avant d’examiner le code, assure-toi que :

• Le code est terminé et ne contient pas de modifications incomplètes.

• Les tests unitaires sont écrits et réussis.

• Le développeur a fait une auto-vérification de son propre code.

• Un pull request (PR) ou une merge request (MR) est créé avec une description claire des changements.

---

2. Lecture et Compréhension du Code

Lors de la revue, vérifie si :

• Le code respecte les exigences fonctionnelles et les spécifications.

• Il est compréhensible et bien structuré.

• La logique métier est bien implémentée.

Bonnes pratiques :

• Lis le PR en entier avant de faire des commentaires.

• Essaie de comprendre l’intention derrière les changements.

---

3. Vérification des Bonnes Pratiques

3.1 Lisibilité et Maintenabilité

✅ Le code doit être lisible et compréhensible :

• Utilisation de noms clairs pour les variables, classes et méthodes.

• Découpage du code en petites méthodes réutilisables.

• Bonne utilisation des commentaires uniquement si nécessaire.

🚫 Éviter :

• Les méthodes trop longues.

• L’utilisation excessive de commentaires inutiles au lieu d’un code clair.

3.2 Respect des Conventions de C#

✅ Vérifie :

• La nomenclature : PascalCase pour classes/méthodes, camelCase pour variables.

• L’indentation et le formatage (utilisation de .editorconfig ou StyleCop).

• L’utilisation de var lorsque le type est évident.

3.3 Performance et Optimisation

✅ Vérifie :

• L’utilisation efficace des collections (List<T>, Dictionary<K, V>, Span<T>).

• L’élimination des allocations inutiles (éviter new inutilement, préférer readonly struct si possible).

• L’optimisation des requêtes LINQ (éviter .ToList() si pas nécessaire).

🚫 Éviter :

• Les boucles inefficaces.

• Les requêtes LINQ imbriquées qui pourraient ralentir les performances.

3.4 Gestion des Erreurs et Exceptions

✅ Vérifie :

• L’utilisation appropriée des exceptions (try-catch pour les erreurs prévisibles).

• L’absence d’exceptions non gérées qui pourraient faire planter l’application.

🚫 Éviter :

• catch (Exception ex) { } sans journalisation.

• L’utilisation excessive d’exceptions au lieu de if pour des erreurs attendues.

3.5 Sécurité

✅ Vérifie :

• L’absence de failles comme l’injection SQL (utiliser des requêtes paramétrées).

• L’utilisation correcte des permissions et validations.

• La non-exposition de données sensibles.

🚫 Éviter :

• Stocker des mots de passe en clair.

• Utiliser string concatenation pour des requêtes SQL.

---

4. Exécution et Tests

4.1 Vérifier les Tests Automatisés

✅ Vérifie :

• La présence de tests unitaires et d’intégration (xUnit, MSTest, NUnit).

• La couverture des cas d’usage et des erreurs (Assert.Throws<Exception>()).

• L’exécution réussie des tests (dotnet test).

🚫 Éviter :

• Accepter du code sans tests.

• Des tests trop dépendants de l’environnement.

4.2 Tester Manuellement si Nécessaire

✅ Tester manuellement certaines parties critiques du code. 🚫 Éviter d’accepter du code qui "semble correct" sans l’essayer.

---

5. Feedback et Amélioration

• Fais des commentaires constructifs et précis :

  • ✅ "Cette méthode pourrait être divisée pour plus de clarté."

  • 🚫 "C’est mal fait."

• Suggère des améliorations plutôt que de critiquer sans solution.

• Discute des points flous pour bien comprendre l’intention du développeur.

• Assure-toi que le développeur a bien appliqué les corrections avant d’approuver.

---

6. Validation et Merge

• Si tous les points sont corrigés, approuve la pull request.

• Vérifie que le code suit bien les règles de versioning (ex: GitFlow).

• Merge la branche après validation.

---

Conclusion

Un bon Code Review en C# suit ces étapes :

1. Préparation (code complet, tests passés).

2. Lecture du code (compréhension et logique métier).

3. Vérification des bonnes pratiques (lisibilité, performance, sécurité).

4. Tests et exécution (automatiques et manuels si besoin).

5. Feedback clair et constructif.

6. Validation et merge.

En appliquant ces principes, tu garantis un code propre, efficace et maintenable. 🚀