Apprendre à configurer Visual Studio Code pour déboguer une application ASP.NET Core
Un billet d'Hinault Romaric

Le , par Hinault Romaric, Responsable .NET
Visual Studio Code est développé en open source par Microsoft et offre aux développeurs le nécessaire (coloration syntaxique, IntelliSence, débogage) pour créer des applications en utilisant l’OS de leur choix (Windows, Linux ou Mac).


Visual Studio Code supporte de nombreux langages de programmation. Celui-ci évolue assez rapidement avec des mises à jour fréquentes. De plus, le support de la communauté permet à sa galerie d’extensions de grandir rapidement et offrir une panoplie d’outils pour étendre les fonctionnalités de l’EDI.

Pour installer Visual Studio Code sous Windows, téléchargez l’exécutable à l’adresse suivante :

https://code.visualstudio.com/Download

Pour mettre en place une application ASP.NET Core avec Visual Studio, vous devez dans un premier temps installer l’extension C# for Visual Studio Code, qui va permettre d’ajouter la prise en charge du langage C# à l’éditeur de code.

Installation de C# for Visual Studio Code

Visual Studio Code n’offre pas un support natif du langage de programmation C#. De ce fait, nous devons installer cette extension pour disposer de la coloration syntaxique pour le langage, l’autocomplétion ou encore le débogage. Pour le faire :
  • cliquez sur le menu View, puis sur Extensions, ou sur l’icône correspondante dans la barre d’outils ;
  • dans la fenêtre qui va s’afficher, saisissez dans la barre de recherche csharp ;
  • cliquez sur Installer pour procéder à l’installation de ce dernier.



Une fois l’installation terminée, vous devez cliquer sur Recharger pour activer cette dernière.

Le framework .NET Core et les outils .NET Core doivent être également installés sur votre poste. Si ce n’est pas encore le cas, vous pouvez les télécharger à l’adresse suivante :

https://www.microsoft.com/net/download/core

Pour créer le projet de démarrage, ouvrez l’invite de commande dans le dossier où le projet doit être créé. Tapez ensuite la commande suivante :

dotnet new web -n testapp

Procédez à la restauration des packages :

cd testapp
dotnet restore

Configuration du débogage avec Visual Studio Code

Ouvrez ensuite le projet avec Visual studio Code. Vous allez lancer le débogage de ce dernier en appuyant sur F5. Une liste déroulante va s’afficher. Vous devez sélectionner l’environnement d’exécution de votre application (.NET Core). Le dossier .vscode sera créé avec le fichier launch.json.



Le fichier launch.json contient les paramètres de configuration qui seront utilisés par Visual Studio Code pour lancer le programme qui s’occupe de la génération (msbuild) et les autres tâches configurées dans le fichier Task.json. Son contenu par défaut est le suivant :

Code json : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
{ 
    "version": "0.2.0", 
    "configurations": [ 
        { 
            "name": ".NET Core Launch (console)", 
            "type": "coreclr", 
            "request": "launch", 
            "preLaunchTask": "build", 
            "program": "${workspaceRoot}/bin/Debug/<target-framework>/<project-name.dll>", 
            "args": [], 
            "cwd": "${workspaceRoot}", 
            "stopAtEntry": false, 
            "console": "internalConsole" 
        }, 
        { 
            "name": ".NET Core Launch (web)", 
            "type": "coreclr", 
            "request": "launch", 
            "preLaunchTask": "build", 
            "program": "${workspaceRoot}/bin/Debug/<target-framework>/<project-name.dll>", 
            "args": [], 
            "cwd": "${workspaceRoot}", 
            "stopAtEntry": false, 
            "launchBrowser": { 
                "enabled": true, 
                "args": "${auto-detect-url}", 
                "windows": { 
                    "command": "cmd.exe", 
                    "args": "/C start ${auto-detect-url}" 
                }, 
                "osx": { 
                    "command": "open" 
                }, 
                "linux": { 
                    "command": "xdg-open" 
                } 
            }, 
            "env": { 
                "ASPNETCORE_ENVIRONMENT": "Development" 
            }, 
            "sourceFileMap": { 
                "/Views": "${workspaceRoot}/Views" 
            } 
        }, 
        { 
            "name": ".NET Core Attach", 
            "type": "coreclr", 
            "request": "attach", 
            "processId": "${command:pickProcess}" 
        } 
    ] 
}

Dans ce fichier, vous avez les configurations pour lancer une application console et une application Web .NET Core. Vous allez supprimer la configuration pour lancer une application console.

Vous devez également modifier la ligne :

Code json : Sélectionner tout
"program": "${workspaceRoot}/bin/Debug/<target-framework>/<project-name.dll>",

Et remplacer les champs <target-framework> par la version du framework .NET que vous utilisez, et <project-name.dll> par le nom de la dll du projet :

Code json : Sélectionner tout
  "program": "${workspaceRoot}/bin/Debug/netcoreapp1.1/testapp.dll",

Son contenu devrait ressembler à ceci :

Code json : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
{ 
    "version": "0.2.0", 
    "configurations": [ 
        { 
            "name": ".NET Core Launch (web)", 
            "type": "coreclr", 
            "request": "launch", 
            "preLaunchTask": "build", 
              "program": "${workspaceRoot}/bin/Debug/netcoreapp1.1/testapp.dll", 
            "args": [], 
            "cwd": "${workspaceRoot}", 
            "stopAtEntry": false, 
            "launchBrowser": { 
                "enabled": true, 
                "args": "${auto-detect-url}", 
                "windows": { 
                    "command": "cmd.exe", 
                    "args": "/C start ${auto-detect-url}" 
                }, 
                "osx": { 
                    "command": "open" 
                }, 
                "linux": { 
                    "command": "xdg-open" 
                } 
            }, 
            "env": { 
                "ASPNETCORE_ENVIRONMENT": "Development" 
            }, 
            "sourceFileMap": { 
                "/Views": "${workspaceRoot}/Views" 
            } 
        }, 
        { 
            "name": ".NET Core Attach", 
            "type": "coreclr", 
            "request": "attach", 
            "processId": "${command:pickProcess}" 
        } 
    ] 
}

Cela fait, appuyez à nouveau sur F5. Vous serez invité cette fois de plus à créer le fichier Task.json. Cliquez sur configurer l’exécuteur de tâches, et dans la liste qui va s’afficher, sélectionnez .NET Core :


Le fichier task.json sera ajouté à votre projet, avec le contenu suivant :

Code json : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{ 
    // See https://go.microsoft.com/fwlink/?LinkId=733558 
    // for the documentation about the tasks.json format 
    "version": "0.1.0", 
    "command": "dotnet", 
    "isShellCommand": true, 
    "args": [], 
    "tasks": [ 
        { 
            "taskName": "build", 
            "args": [], 
            "isBuildCommand": true, 
            "showOutput": "silent", 
            "problemMatcher": "$msCompile" 
        } 
    ] 
}

Vous devez modifier ce dernier pour passer en argument le chemin vers le fichier .csproj à la tâche de build de votre projet :

Code json : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{ 
    // See https://go.microsoft.com/fwlink/?LinkId=733558 
    // for the documentation about the tasks.json format 
    "version": "0.1.0", 
    "command": "dotnet", 
    "isShellCommand": true, 
    "args": [], 
    "tasks": [ 
        { 
            "taskName": "build", 
            "args": ["${workspaceRoot}\\testapp.csproj"], 
            "isBuildCommand": true, 
            "showOutput": "silent", 
            "problemMatcher": "$msCompile" 
        } 
    ] 
}

Il nous manque encore un dernier élément pour déboguer notre application : l’installation du débogueur pour .NET Core. Pour l’installer, ouvrez la Palette de commandes (Affichage/Palette de commandes) et saisissez debug, puis sélectionnez « Debug : Download .NET Core Debugger ».


Appuyez à nouveau sur F5. Le débogage de votre application va se lancer, et si vous mettez un point d’arrêt dans le fichier Startup.cs, vous aurez le résultat suivant :



Bon débogage avec Visual Studio Code.


Vous avez aimé cette actualité ? Alors partagez-la avec vos amis en cliquant sur les boutons ci-dessous :
Offres d'emploi IT
Ingénieur produit (Landing gear) H/F
Safran - Ile de France - MASSY Hussenot
Ingénieur système de commande de vol H/F
Safran - Ile de France - Massy (91300)
Ingénieur conception électrique / électronique H/F
Safran - Ile de France - Villaroche

Voir plus d'offres Voir la carte des offres IT
Contacter le responsable de la rubrique Accueil