Faire fonctionner le code dans Visual Studio
Visual Studio inclut un ensemble puissant d’outils de génération et de débogage de projets. Cet article explique comment Visual Studio permet de trouver les problèmes de votre code à l’aide de la sortie de la génération, de l’analyse du code, des outils de débogage et des tests unitaires.
Vous avez compris comment fonctionne l’éditeur et vous venez de créer du code. Vous voulez maintenant vérifier que le code fonctionne correctement. Dans Visual Studio, comme dans la plupart des environnements de développement intégrés (IDE), vérifier le bon fonctionnement du code se fait en deux phases : la génération du code, pour détecter et résoudre les erreurs liées au projet et au compilateur, puis l’exécution du code pour trouver les erreurs dynamiques et d’exécution.
Générer votre code
Il existe deux types de base de configurations de build : Debug et Release. La configuration Debug produit un fichier exécutable plus lent et plus grand, qui rend l’expérience de débogage à l’exécution plus riche et interactive. L’exécutable Debug ne doit jamais être publié. La configuration Release génère un fichier exécutable plus rapide et optimisé, qui peut être livré (au moins du point de vue du compilateur). La configuration de build par défaut est Debug.
Le moyen le plus simple de générer votre projet est d’appuyer sur F7, mais vous pouvez aussi démarrer la génération en sélectionnant Générer>Générer la solution dans le menu principal.
Vous pouvez observer le processus de génération dans la fenêtre Sortie, qui se trouve dans la partie inférieure de l’interface utilisateur de Visual Studio (interface utilisateur). Les erreurs, avertissements et opérations de génération sont affichés ici. Si vous avez des erreurs (ou si vous recevez des avertissements au-delà d’un niveau configuré), votre build échoue. Vous pouvez sélectionner une erreur ou un avertissement pour accéder à la ligne où s’est produit le problème. Regénérez votre projet en réappuyant sur F7 (pour recompiler seulement les fichiers avec des erreurs) ou en appuyant sur Ctrl+Alt+F7 (pour une regénération complète).
Vous pouvez voir deux fenêtres à onglets dans la fenêtre de résultats sous l’éditeur : la fenêtre Sortie, qui contient la sortie brute du compilateur (notamment les messages d’erreur), et la fenêtre Liste d’erreurs, qui fournit une liste de l’ensemble des erreurs et des avertissements, que vous pouvez trier et filtrer.
Quand la build réussit, des résultats similaires à ceux-ci apparaissent dans la fenêtre Sortie :
Examiner la Liste d’erreurs
À moins que vous n’ayez apporté aucune modification au code précédemment compilé avec succès, une erreur s’est probablement produite. Si vous codez depuis peu, il y en a peut-être beaucoup. Si certaines erreurs sont évidentes, comme une simple erreur de syntaxe ou un nom de variable incorrect, d’autres sont parfois plus ardues à comprendre. Et ce n’est pas le code obscur associé qui va davantage vous aider. Pour une vue plus claire des problèmes, accédez au bas de la fenêtre Sortie de build, puis sélectionnez l’onglet Liste d’erreurs. Cette action renvoie à une vue plus organisée des erreurs et des avertissements pour votre projet, et offre également des options supplémentaires.
Sélectionnez la ligne de l’erreur dans la fenêtre Liste d’erreurs pour accéder directement à la ligne où l’erreur s’est produite. (Ou activez les numéros de ligne en appuyant sur Ctrl+Q, en tapant numéros de ligne, puis en choisissant Activer ou désactiver les numéros de ligne dans les résultats. Cette action est le moyen le plus rapide d’accéder à la boîte de dialogue Options où vous pouvez activer les numéros de ligne.)
Appuyez sur Ctrl+G pour accéder rapidement au numéro de ligne où l’erreur s’est produite.
Visual Studio identifie cette erreur par une ligne ondulée rouge. Pointez dessus pour afficher plus d’informations. Corrigez l’erreur pour la faire disparaître. Notez toutefois que vous risquez d’introduire une nouvelle erreur. (Cette action s’appelle une « régression ».)
Passez en revue la liste d'erreurs et corrigez toutes les erreurs dans votre code.
Examiner les erreurs en détail
De nombreuses erreurs, exprimées selon les termes du compilateur, peuvent sembler incompréhensibles. Dans ces cas-là, vous avez besoin d’informations supplémentaires. Dans la fenêtre Liste d’erreurs, vous pouvez effectuer une recherche Bing automatique pour plus d’informations sur l’erreur ou l’avertissement. Cliquez avec le bouton droit sur la ligne d’entrée correspondante, puis sélectionnez Afficher l’aide sur l’erreur dans le menu contextuel, ou sélectionnez le lien hypertexte contenant la valeur du code d’erreur dans la colonne Code de la Liste d’erreurs.
En fonction de vos paramètres, votre navigateur web affiche les résultats de la recherche pour le code et le texte de l’erreur, ou un onglet s’ouvre dans Visual Studio et montre les résultats de la recherche Bing. Les résultats provenant de sources diverses sur Internet, certains peuvent s’avérer inutiles.
Utiliser l’analyse du code
Les analyseurs de code recherchent les problèmes de code courants qui peuvent conduire à des erreurs d’exécution ou à des problèmes dans la gestion du code.
Analyse du code C# et Visual Basic
Visual Studio comprend un ensemble prédéfini d’analyseurs .NET Compiler Platform qui examinent le code C# et Visual Basic au fur et à mesure que vous l’écrivez. Vous pouvez installer d’autres analyseurs en tant qu’extension Visual Studio ou en tant que package NuGet. Si des violations de règle sont détectées, elles sont signalées à la fois dans la Liste d’erreurs et dans l’éditeur de code, où le code incriminé est identifié par une ligne ondulée.
Analyse du code C++
Pour analyser du code C++, exécutez une analyse statique du code. Prenez l’habitude d’effectuer cette analyse après avoir résolu les erreurs évidentes qui font obstacle à la génération. Prenez le temps de traiter des avertissements éventuels. Cela vous évitera des maux de tête et vous pourrez découvrir quelques techniques relatives au style du code.
Appuyez sur Alt+F11 (ou sélectionnez Analyser>Exécuter l’analyse du code sur la solution dans le menu du haut) pour démarrer l’analyse statique du code.
Les avertissements nouveaux ou mis à jour apparaissent sous l’onglet Liste d’erreurs dans la partie inférieure de l’IDE. Sélectionnez un avertissement pour y accéder dans le code.
Utiliser les actions rapides pour corriger ou refactoriser du code
Les actions rapides, disponibles à partir de l’icône d’ampoule ou de tournevis, permettent de refactoriser le code inline. Elles vous permettent de résoudre facilement et rapidement les avertissements courants dans du code C#, C++ et Visual Basic. Pour y accéder, cliquez avec le bouton droit sur le trait de soulignement ondulé d’un avertissement et sélectionnez Actions rapides et refactorisations. Ou bien, quand votre curseur est sur la ligne marquée d’une ligne ondulée en couleur, appuyez sur Ctrl+. ou sélectionnez l’icône d’ampoule, d’ampoule d’erreur ou de tournevis dans la marge. Visual Studio affiche ensuite une liste des corrections ou des refactorisations possibles que vous pouvez appliquer à cette ligne de code.
Vous pouvez utiliser des actions rapides là où les analyseurs de code déterminent que votre code peut être corrigé, refactorisé ou amélioré. Sélectionnez une ligne de code, cliquez avec le bouton droit pour ouvrir le menu contextuel, puis sélectionnez Actions rapides et refactorisations. Si des options de refactorisation ou d’amélioration sont disponibles, elles sont affichées. Sinon, le message Aucune action rapide disponible ici apparaît en bas à gauche de l’IDE.
Avec plus d’expérience, vous pouvez aller plus vite et utiliser les touches de direction et Ctrl+. pour vérifier les opportunités de refactorisation simples et nettoyer votre code.
Exécuter le nettoyage du code
Visual Studio fournit une mise en forme à la demande de votre fichier de code C#, y compris les préférences de style de code, via le bouton Nettoyage du code en bas de l’éditeur.
En plus de mettre en forme votre fichier avec des espaces, retraits, etc., le nettoyage de code applique également un ensemble de conventions de style de code que vous définissez. Vos préférences pour chaque style de code sont lues à partir du fichier EditorConfig, si vous en avez un pour le projet, ou à partir des paramètres de style de code dans la boîte de dialogue Options.
Déboguer votre code en cours d’exécution
Maintenant que vous avez généré votre code et effectué quelques tâches de nettoyage, exécutez-le en appuyant sur F5 ou en sélectionnant Déboguer>Démarrer le débogage. Cette action démarre votre application dans un environnement de débogage afin que vous puissiez observer son comportement en détail. Pendant l’exécution de votre application, l’IDE de Visual Studio subit des modifications. Ainsi, la fenêtre Sortie est remplacée par deux nouvelles fenêtres (dans la configuration des fenêtres par défaut) : une fenêtre avec les onglets Automatique/Variables locales/Espion et une autre avec les onglets Pile des appels/Points d’arrêt/Paramètres d’exception/Sortie. Ces fenêtres ont plusieurs onglets qui vous permettent d’inspecter et d’évaluer les variables, threads, piles d’appels et autres comportements de votre application à mesure qu’elle s’exécute.
Arrêtez votre application en appuyant sur Maj+F5 ou en cliquant sur le bouton Arrêter. Vous pouvez aussi simplement fermer la fenêtre principale de l’application (ou la boîte de dialogue de la ligne de commande).
Si votre code s'exécute parfaitement et exactement comme prévu, félicitations ! Toutefois, votre code peut parfois cesser de répondre, se bloquer ou vous donner des résultats étranges. Si c’est le cas, vous devez essayer de trouver la source de ces problèmes et de corriger les bogues.
Définir des points d’arrêt simples
Les points d’arrêt constituent la fonctionnalité la plus élémentaire et la plus essentielle pour un débogage fiable. Quand vous définissez un point d’arrêt, Visual Studio interrompt l’exécution du code à l’emplacement du point d’arrêt pour vous permettre d’examiner les valeurs des variables, le comportement de la mémoire ou encore la bonne exécution d’une branche de code. Vous n’avez pas besoin de regénérer un projet après avoir défini et supprimé des points d’arrêt.
Définissez un point d’arrêt en cliquant à l’extrémité de la marge de la ligne où vous souhaitez arrêter le code, ou appuyez sur F9 pour définir un point d’arrêt sur la ligne de code actuelle. Quand vous exécutez votre code, celui-ci s’interrompt (ou s’arrête) avant d’exécuter les instructions contenues dans cette ligne de code.
Parmi les utilisations courantes des points d'arrêt, citons les suivantes :
Pour cibler la source d’un plantage ou d’un programme ne répondant pas, disséminez des points d’arrêt à l’intérieur et tout autour du code de l’appel de méthode qui semble être à l’origine de l’échec. À mesure que vous exécutez le code dans le débogueur, supprimez les points d’arrêt, puis rapprochez-les les uns des autres jusqu’à identifier la ligne de code incriminée. Pour découvrir comment exécuter du code dans le débogueur, consultez la section suivante.
Quand vous introduisez du nouveau code, définissez un point d’arrêt au début du code, puis exécutez le code pour vérifier qu’il se comporte comme prévu.
Si vous avez implémenté un comportement complexe, définissez des points d’arrêt dans le code de l’algorithme, pour pouvoir inspecter les valeurs des variables et des données quand le programme s’arrête.
Si vous écrivez du code C ou C++, utilisez des points d’arrêt pour arrêter le code pour pouvoir inspecter les valeurs d’adresse (rechercher NULL) et les nombres de références lors du débogage des échecs liés à la mémoire.
Pour plus d’informations sur l’utilisation des points d’arrêt, consultez Utiliser des points d’arrêt dans le débogueur Visual Studio.
Inspecter le code au moment de l’exécution
Quand votre code qui s’exécute atteint un point d’arrêt et s’interrompt, la ligne de code marquée en jaune (représentant l’instruction en cours) n’a pas encore été exécutée. À ce stade, vous pouvez exécuter l’instruction en cours, puis inspecter les valeurs modifiées. Vous pouvez utiliser plusieurs commandes d’analyse pas à pas pour exécuter le code dans le débogueur. Si le code marqué est un appel de méthode, vous pouvez effectuer un pas à pas détaillé en appuyant sur F11. Vous pouvez également exécuter pas à pas la ligne de code en appuyant sur F10. Pour plus d’informations sur les autres commandes et sur la façon d’exécuter le code pas à pas, consultez Naviguer dans le code à l’aide du débogueur.
Dans l’illustration précédente, vous pouvez avancer d’une instruction dans le débogueur en appuyant sur F10 ou F11 (comme il n’y a ici aucun appel de méthode, les deux commandes ont le même résultat).
Quand le débogueur est suspendu, vous pouvez inspecter les variables et les piles des appels pour déterminer ce qui se passe. Les valeurs sont-elles comprises dans les plages attendues ? Les appels sont-ils effectués dans le bon ordre ?
Placez le curseur sur une variable pour voir sa valeur actuelle et ses références. Si vous remarquez une valeur inattendue, vous avez probablement un bogue dans les lignes de code précédentes ou dans le code appelant. Pour en savoir plus, consultez Découverte du débogueur Visual Studio.
Par ailleurs, Visual Studio affiche la fenêtre Outils de diagnostic. Celle-ci vous permet d’observer l’utilisation au fil du temps de l’UC et de la mémoire par votre application. Ultérieurement lors du développement de vos applications, vous pourrez utiliser ces outils pour rechercher les utilisations du processeur ou les allocations de mémoire importantes et imprévues. Utilisez-les avec la fenêtre Espion et les points d’arrêt pour déterminer le problème à l’origine d’une forte utilisation inattendue ou de la non-libération de ressources. Pour plus d’informations, consultez Découverte des outils de profilage (C#, Visual Basic, C++, F#).
Exécuter des tests unitaires
Les tests unitaires sont votre première ligne de défense contre les bogues du code car, exécutés correctement, ils testent une seule « unité » de code, généralement une seule fonction, et leur débogage est généralement plus facile que celui du programme complet. Visual Studio installe les infrastructures de tests unitaires Microsoft pour le code managé et le code natif. Utilisez une infrastructure de test unitaire pour créer des tests unitaires, les exécuter et signaler les résultats de ces tests. Réexécutez les tests unitaires quand vous apportez des modifications pour vérifier que votre code fonctionne toujours correctement. Avec Visual Studio Enterprise Edition, vous pouvez exécuter automatiquement des tests après chaque build.
Pour démarrer, consultez Générer des tests unitaires pour les tests à données aléatoires à l’aide d’IntelliTest.
Pour plus d’informations sur les tests unitaires dans Visual Studio et comment ils peuvent vous aider à créer du code de meilleure qualité, consultez Concepts de base des tests unitaires.