Techniques de débogage en C#

Dans le processus de développement logiciel, le débogage (debugging) est un processus systématique consistant à analyser le comportement inattendu d’un programme et à identifier le code défectueux. En C#, des outils comme Visual Studio et Visual Studio Code offrent de puissantes fonctionnalités de débogage, permettant aux développeurs de suivre pas à pas l’exécution du code, d’inspecter les valeurs des variables et d’analyser le flux du programme.

Différence entre les modes Debug et Release

Les projets .NET disposent de deux modes de compilation principaux :

• Debug : Utilisé pendant le développement. Contient des symboles et des informations supplémentaires pour faciliter le débogage.
• Release : Utilisé pour la version de production. Les optimisations sont appliquées et les informations de débogage sont supprimées.

// Dans Visual Studio, sélectionnable dans le menu supérieur :
// [Debug ▼] → [Release]

En mode Debug, le programme peut être exécuté ligne par ligne, offrant un contrôle total sur le flux du code.

Points d’arrêt (Breakpoints)

Un point d’arrêt est un marqueur qui arrête le programme à une ligne spécifique. Cela permet au programme de s’exécuter jusqu’à ce point et, une fois arrêté, d’inspecter les valeurs actuelles de toutes les variables.

class Program
{
    static void Main()
    {
        int a = 5;
        int b = 0;
        int c = a / b; // Erreur : DivideByZeroException
        Console.WriteLine(c);
    }
}

Dans l’exemple ci-dessus, vous pouvez placer un point d’arrêt sur la ligne int c = a / b; afin que l’exécution s’arrête et que vous puissiez examiner les valeurs de a et b dans la fenêtre “Locals”.

Commandes de pas à pas (Stepping)

Visual Studio fournit plusieurs raccourcis clavier pour exécuter le code étape par étape :

• F10 – Step Over : Exécute la ligne actuelle sans entrer dans les méthodes appelées.
• F11 – Step Into : Entre dans la méthode appelée sur la ligne actuelle.
• Shift + F11 – Step Out : Quitte la méthode actuelle.
• F5 – Continue : Exécute le programme jusqu’au prochain point d’arrêt.

Ces outils permettent un contrôle complet sur le flux du programme et facilitent l’identification précise de l’origine d’une erreur.

Surveillance des variables (Watch et Autos)

Visual Studio permet de suivre les valeurs des variables en temps réel pendant le débogage :

• Fenêtre Watch : Affiche les variables ajoutées manuellement pour les surveiller.
• Fenêtre Locals : Liste automatiquement toutes les variables de la portée actuelle.
• Fenêtre Autos : Affiche les variables liées aux dernières lignes exécutées.

En survolant une variable avec la souris, sa valeur actuelle apparaît dans une info-bulle.

Utilisation des fenêtres Immediate et Watch

La fenêtre Immediate permet d’exécuter du code directement pendant le débogage. Vous pouvez modifier les valeurs des variables ou tester de petites expressions sans redémarrer le programme.

// Exemple de fenêtre Immediate :
// ? a + b
// ? myList.Count
// a = 25

Cela permet de tester des calculs et d’ajuster les valeurs des variables sans relancer l’application.

Points d’arrêt conditionnels

Parfois, vous ne souhaitez pas que le programme s’arrête à chaque itération, mais seulement lorsqu’une certaine condition est remplie. Pour cela, vous pouvez utiliser un point d’arrêt conditionnel.

for (int i = 0; i < 100; i++)
{
    Console.WriteLine(i);
}

Après avoir ajouté un point d’arrêt dans cette boucle, ouvrez le menu “Conditions” et définissez i == 50 — le programme s’arrêtera uniquement lorsque i sera égal à 50.

Paramètres des exceptions

Dans le menu Debug → Windows → Exception Settings, vous pouvez choisir les types d’exceptions pour lesquels le programme doit s’arrêter. Par exemple, vous pouvez définir un arrêt uniquement pour NullReferenceException ou InvalidOperationException.

Cette fonctionnalité évite les arrêts inutiles dans les applications complexes.

Débogage dans les blocs Try / Catch

Même si les erreurs sont capturées dans un bloc try / catch, Visual Studio peut s’arrêter sur la ligne où l’exception se produit si l’option “Break on User-Unhandled Exceptions” est activée.

try
{
    int[] tableau = new int[3];
    tableau[5] = 10; // IndexOutOfRangeException
}
catch (Exception ex)
{
    Console.WriteLine("Exception capturée : " + ex.Message);
}

Cela vous permet d’examiner l’état de l’application juste avant que l’exception ne soit levée.

Utilisation de Debug.WriteLine()

La méthode Debug.WriteLine() écrit des messages d'information dans la fenêtre de sortie (Output Window) pendant le débogage. Elle est utile pour enregistrer des journaux en arrière-plan sans modifier la sortie de la console.

using System.Diagnostics;

class Program
{
    static void Main()
    {
        for (int i = 0; i < 3; i++)
        {
            Debug.WriteLine($"Étape {i} terminée.");
        }
        Console.WriteLine("Programme terminé.");
    }
}

Ces messages ne sont visibles qu’en mode Debug et ne s’exécutent pas en mode Release.

Journalisation et suivi des erreurs

Le débogage ne sert pas seulement à l’analyse en temps réel, mais aussi au suivi à long terme d’une application. Pour cela, on peut utiliser des bibliothèques de journalisation telles que Serilog, NLog ou Microsoft.Extensions.Logging.

using Microsoft.Extensions.Logging;

class Program
{
    static void Main()
    {
        using var loggerFactory = LoggerFactory.Create(builder =>
        {
            builder.AddConsole();
        });
        var logger = loggerFactory.CreateLogger<Program>();

        try
        {
            int a = 10, b = 0;
            int c = a / b;
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Une erreur est survenue !");
        }
    }
}

La journalisation permet de suivre les erreurs non seulement pendant le développement, mais aussi dans les environnements de production.

Exemple : Débogage d'une connexion utilisateur

Le programme s'arrêtera à la ligne où vous placez le point d'arrêt (breakpoint).

L'exemple suivant montre comment identifier une erreur dans un formulaire de connexion utilisateur étape par étape avec le débogueur.

class LoginService
{
    public bool Login(string username, string password)
    {
        if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
            throw new ArgumentException("Le nom d'utilisateur ou le mot de passe ne peut pas être vide.");

        return username == "admin" && password == "1234";
    }
}

class Program
{
    static void Main()
    {
        var service = new LoginService();
        Console.Write("Nom d'utilisateur : ");
        string? u = Console.ReadLine();
        Console.Write("Mot de passe : ");
        string? p = Console.ReadLine();

        try
        {
            bool result = service.Login(u, p);
            Console.WriteLine(result ? "Connexion réussie" : "Identifiants invalides");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Erreur : {ex.Message}");
        }
    }
}

Vous pouvez placer un point d'arrêt sur n'importe quelle ligne et inspecter les variables pas à pas.

En plaçant un point d'arrêt sur la ligne return, vous pouvez examiner les valeurs de username et password en temps réel et analyser pourquoi la condition renvoie false.

Bonnes pratiques

• Ne placez pas chaque ligne dans un bloc try / catch — gérez les exceptions dans des couches spécifiques (par ex. interface utilisateur ou service).
• Utilisez Debug.WriteLine ou un framework de journalisation au lieu de Console.WriteLine.
• Utilisez « Step Over » au lieu de « Step Into » pour éviter les détails inutiles.
• Utilisez des points d'arrêt conditionnels pour vous concentrer sur des scénarios précis.
• Utilisez des techniques de simulation d'exception pour tester la gestion des erreurs (ex : entrées invalides, valeurs nulles).

TL;DR

Articles connexes