Réusinage de code legacy en C# : guide complet de A à Z

Réusinage de code legacy en C# : de A à Z

Travailler avec du code hérité (legacy) est une réalité inévitable pour tout développeur .NET. Les anciens projets en C# contiennent souvent du "code spaghetti", des nombres magiques, des classes énormes et une absence de tests. Au lieu de tout réécrire de zéro (ce qui est coûteux et risqué), un réusinage judicieux permet d'améliorer progressivement le code, réduisant ainsi la dette technique. Dans cet article, nous allons détailler une stratégie pas à pas pour le réusinage de code legacy en C# avec des exemples concrets.

1. Préparation au réusinage : la sécurité avant tout

La règle d'or du réusinage de code legacy est ne pas casser ce qui fonctionne. Sans tests, toute modification peut entraîner des bugs en production. La première étape consiste donc à créer un "filet de sécurité".

1.1. Ajout de tests (Characterization Tests)

S'il n'y a pas de tests, il faut en écrire. Utilisez l'approche des Characterization Tests (tests de caractérisation). Le principe : vous exécutez le code existant avec différentes données d'entrée et vous fixez le comportement actuel comme référence.

// Exemple pour une méthode legacypublic class LegacyCalculator{    public int CalculateTotal(int a, int b)    {        // Code legacy que nous ne comprenons pas entièrement        return a + b * 2; // Logique suspecte    }}

// Test de caractérisation[Test]public void CalculateTotal_WhenCalled_ReturnsCurrentBehavior(){    var calc = new LegacyCalculator();    int result = calc.CalculateTotal(3, 4);    // On fixe le résultat actuel comme attendu    Assert.AreEqual(11, result); // 3 + 4*2 = 11}

Après avoir écrit de tels tests, vous pouvez réusiner en toute confiance, sachant que les tests détecteront les régressions.

1.2. Isolation des dépendances

Le code legacy est souvent fortement couplé à la base de données, au système de fichiers ou à des services externes. Utilisez Extract Interface et l'injection de dépendances (DI) pour l'isoler.

// Avant : dépendance fortepublic class OrderProcessor{    private readonly SqlDatabase _db = new SqlDatabase();        public void Process(Order order)    {        _db.Save(order);    }}

// Après : interface et DIpublic interface IOrderRepository{    void Save(Order order);}

public class OrderProcessor{    private readonly IOrderRepository _repository;        public OrderProcessor(IOrderRepository repository)    {        _repository = repository;    }        public void Process(Order order)    {        _repository.Save(order);    }}

2. Techniques principales de réusinage du code C# legacy

Après la préparation, vous pouvez commencer à améliorer le code. Voici les techniques clés qui fonctionnent avec les projets .NET.

2.1. Extract Method (Extraction de méthode)

Les méthodes énormes de 200+ lignes sont un classique du legacy. Divisez-les en petites méthodes lisibles.

// Avant le réusinagepublic void ProcessInvoice(Invoice invoice){    // 50 lignes de calcul de remise    decimal discount = 0;    if (invoice.Total > 1000) discount = 0.1m;    else if (invoice.Total > 500) discount = 0.05m;    // ... encore beaucoup de code        // 30 lignes d'envoi d'email    // ... }

// Après le réusinagepublic void ProcessInvoice(Invoice invoice){    decimal discount = CalculateDiscount(invoice.Total);    SendInvoiceEmail(invoice);}

private decimal CalculateDiscount(decimal total){    if (total > 1000) return 0.1m;    if (total > 500) return 0.05m;    return 0;}

private void SendInvoiceEmail(Invoice invoice){    // Logique d'envoi}

2.2. Replace Magic Numbers with Constants

Les nombres magiques rendent le code incompréhensible. Remplacez-les par des constantes.

// Mauvaisif (user.Role == 3) { /* admin */ }

// Bonpublic enum UserRole{    Guest = 1,    User = 2,    Admin = 3}

if (user.Role == (int)UserRole.Admin) { /* admin */ }