Clean Code en C# : principes d'écriture de code lisible avec exemples

Introduction : Pourquoi un code propre est-il la clé d’un projet réussi ?

Dans le monde du développement logiciel sur la plateforme .NET, écrire du code fonctionnel n’est que la moitié du travail. La véritable maîtrise réside dans la capacité à créer un code facile à lire, à maintenir et à étendre. Le concept de Clean Code, popularisé par Robert Martin, est un ensemble de principes qui transforment un programme chaotique en un système structuré et compréhensible. Pour un développeur C#, suivre ces principes signifie non seulement du respect envers ses collègues, mais aussi une réduction significative du temps de débogage et d’implémentation de nouvelles fonctionnalités.

Dans cet article, nous allons analyser les principes clés du Clean Code appliqués au langage C# et au framework .NET. Vous verrez des exemples concrets de code « mauvais » et « bon » qui vous aideront à écrire des applications de meilleure qualité.

Principe 1 : Des noms explicites et un style uniforme

Nommer correctement les variables et les méthodes

Le nom d’une variable, d’une classe ou d’une méthode doit répondre aux questions : « Qu’est-ce que c’est ? » ou « Que fait-elle ? ». Évitez les abréviations d’une seule lettre (sauf pour les compteurs de boucles) et les noms abstraits comme data, info, temp.

Mauvais exemple :

public int Calc(int a, int b) // Que sont a et b ? Que fait la méthode ?{    int d = a * b;    return d;}

Bon exemple (Clean Code) :

/// <summary>/// Calcule la surface d’un rectangle./// </summary>public int CalculateRectangleArea(int width, int height){    int area = width * height;    return area;}

Uniformité au sein de l’équipe

Utilisez camelCase pour les variables locales et les paramètres, PascalCase pour les méthodes et les classes, _camelCase pour les champs privés (selon les directives populaires .NET). Cela rend le code prévisible.

public class OrderService{    private readonly IOrderRepository _orderRepository; // champ privé

    public async Task<Order> GetOrderByIdAsync(int orderId) // méthode    {        var order = await _orderRepository.FindAsync(orderId); // variable locale        return order;    }}

Principe 2 : Petites fonctions et principe de responsabilité unique (SRP)

Une fonction ne doit faire qu’une seule chose

C’est le principe le plus important du Clean Code. Si une méthode effectue plusieurs actions (validation, journalisation, logique métier, sauvegarde en base de données), elle est difficile à tester et à modifier. Divisez ces méthodes en plus petites.

Mauvais exemple (la méthode fait tout à la fois) :

public void ProcessOrder(Order order){    // 1. Validation    if (order == null || order.TotalAmount <= 0)        throw new ArgumentException("Invalid order");

    // 2. Journalisation    Console.WriteLine($"Processing order {order.Id}");

    // 3. Logique métier    var discount = order.TotalAmount > 100 ? 0.1m : 0;    order.FinalAmount = order.TotalAmount - (order.TotalAmount * discount);

    // 4. Sauvegarde    _context.Orders.Add(order);    _context.SaveChanges();}

Bon exemple (division en méthodes) :

public void ProcessOrder(Order order){    ValidateOrder(order);    LogOrderProcessing(order);    ApplyDiscount(order);    SaveOrder(order);}

private void ValidateOrder(Order order){    if (order == null || order.TotalAmount <= 0)        throw new ArgumentException("Invalid order", nameof(order));}

private void LogOrderProcessing(Order order){    Console.WriteLine($"Processing order {order.Id}");}

private void ApplyDiscount(Order order){    const decimal discountThreshold = 100m;    const decimal discountRate = 0.1m;

    if (order.TotalAmount > discountThreshold)    {        order.FinalAmount = order.TotalAmount - (or