Module C#.12 – Bonnes pratiques

Objectif

Appliquer les bonnes pratiques C# : SOLID (introduction), conventions de nommage, et architecture simple pour créer du code professionnel et maintenable.

Théorie

SOLID (introduction)

Principes de conception orientée objet.

S - Single Responsibility Principle

Une classe doit avoir une seule raison de changer.

// ❌ Mauvais : fait trop de choses
class Personne
{
    public void Valider() { }
    public void Sauvegarder() { }
    public void EnvoyerEmail() { }
}

// ✅ Bon : séparé
class Personne { }
class PersonneValidator { }
class PersonneRepository { }
class EmailService { }

O - Open/Closed Principle

Ouvert à l'extension, fermé à la modification.

// Utiliser l'héritage et les interfaces
abstract class Forme
{
    public abstract double CalculerAire();
}

class Cercle : Forme
{
    public double Rayon { get; set; }
    public override double CalculerAire() => Math.PI * Rayon * Rayon;
}

L - Liskov Substitution Principle

Les sous-classes doivent être substituables à leur classe de base.

// Les objets enfants doivent pouvoir remplacer les parents
Personne p = new Etudiant("Jean", 20, "ESIEA");
p.Afficher();  // Doit fonctionner correctement

I - Interface Segregation Principle

Interfaces spécifiques plutôt que générales.

// ❌ Mauvais : interface trop générale
interface ITravailleur
{
    void Travailler();
    void Manger();
    void Dormir();
}

// ✅ Bon : interfaces spécifiques
interface ITravailleur
{
    void Travailler();
}

interface IMangeur
{
    void Manger();
}

D - Dependency Inversion Principle

Dépendre d'abstractions, pas de concret.

// Dépendre d'interfaces, pas de classes concrètes
class PersonneService
{
    private readonly IPersonneRepository _repository;
    
    public PersonneService(IPersonneRepository repository)
    {
        _repository = repository;
    }
}

Conventions de nommage

Classes : PascalCase

class Personne {}
class GestionnaireUtilisateurs {}

Méthodes : PascalCase

void CalculerMoyenne() {}
string ObtenirNom() {}

Variables : camelCase

int nomUtilisateur = 30;
string messageErreur = "Erreur";

Constantes : UPPER_SNAKE_CASE

const int MAX_SIZE = 100;
const string API_URL = "https://api.exemple.com";

Interfaces : I + PascalCase

interface IAffichable {}
interface IPersonneRepository {}

Champs privés : _camelCase ou camelCase

private int _age;
private string nom;

Architecture simple

Séparation des responsabilités

MVC (Model-View-Controller) :

• Model : Données et logique métier
• View : Affichage (console, GUI, etc.)
• Controller : Coordination entre Model et View

Structure :

projet/
├── Models/          # Modèles de données
├── Services/        # Logique métier
├── Controllers/     # Contrôleurs
├── Repositories/    # Accès données
└── Utils/           # Utilitaires

Documentation XML

/// <summary>
/// Calcule la moyenne de deux nombres
/// </summary>
/// <param name="a">Premier nombre</param>
/// <param name="b">Deuxième nombre</param>
/// <returns>La moyenne des deux nombres</returns>
/// <exception cref="ArgumentException">Si les nombres sont invalides</exception>
public double Moyenne(double a, double b)
{
    return (a + b) / 2;
}

Génération :

dotnet build /p:GenerateDocumentationFile=true

Exercice

1. SOLID

   • Refactorisez du code selon SOLID
   • Séparez les responsabilités
   • Utilisez interfaces

2. Conventions

   • Appliquez les conventions C#
   • Organisez vos classes
   • Respectez le nommage

3. Architecture

   • Organisez en namespaces
   • Séparez les responsabilités
   • Créez une structure MVC

4. Documentation

   • Ajoutez des commentaires XML
   • Générez la documentation
   • Vérifiez le résultat

5. Code propre

   • Refactorisez selon Clean Code
   • Améliorez les noms
   • Raccourcissez les méthodes

Quiz

1. Que signifie SOLID ?

   • Simple Object Logic Interface Design
   • Single Responsibility, Open/Closed, Liskov, Interface Segregation, Dependency Inversion
   • Solid Object Language

2. Quelle convention pour les classes ?

   • camelCase
   • PascalCase
   • UPPER_CASE

3. Que signifie Single Responsibility ?

   • Une seule méthode
   • Une classe, une responsabilité
   • Une seule propriété

4. Que fait Dependency Inversion ?

   • Inverse les dépendances
   • Dépendre d'abstractions, pas de concret
   • Supprime les dépendances

5. Comment documenter une méthode ?

   • // Commentaire
   • /// Commentaire XML
   • /* Commentaire */

Mini défi

Mission : Refactoriser un projet selon les bonnes pratiques

Prenez un projet C# existant et refactorisez-le :

Améliorations :

1. SOLID (séparation responsabilités)
2. Conventions C# (nommage, structure)
3. Architecture (MVC, séparation)
4. Documentation XML complète
5. Code propre et maintenable

Critères :

• ✅ Code conforme SOLID
• ✅ Conventions respectées
• ✅ Documentation complète
• ✅ Structure professionnelle

Objectif : Appliquer toutes les bonnes pratiques pour créer du code professionnel.

---

Validation : Vous pouvez passer au module suivant quand votre code respecte les bonnes pratiques.