Créer des tâches de génération et de débogage pour le développement « Ouvrir le dossier »

Visual Studio peut exécuter automatiquement de nombreux langages de programmation et codebases différents. L’option Ouvrir le dossier vous permet d’exécuter immédiatement du code pour un codebase reconnu sans instructions spéciales et sans créer de projet. Les développeurs utilisent généralement cette approche pour les tests rapides.

Certains codebases nécessitent des outils de génération personnalisés que Visual Studio ne reconnaît pas ou ne peut pas traiter immédiatement avec l’option Ouvrir le dossier. Pour ces scénarios, vous pouvez définir des tâches de génération pour indiquer à Visual Studio comment générer et déboguer le code. Les tâches de génération spécifient tous les éléments dont un langage a besoin pour générer et exécuter le code, et peuvent être utilisées pour effectuer presque toutes les opérations requises.

Cet article explique comment définir des tâches de génération pour configurer des paramètres de génération et de débogage pour un codebase sans connaissances et sans projet dans Visual Studio.

Explorer les fichiers de configuration JSON

Pour personnaliser un codebase sans projet, Visual Studio fournit deux fichiers JSON (.json) pour les paramètres de configuration : tasks et launch. Visual Studio crée (ou ouvre) ces fichiers en fonction des besoins, lorsque vous sélectionnez des options spécifiques dans Explorateur de solutions de Visual Studio.

Le tableau suivant décrit les fichiers JSON et comment les créer dans Explorateur de solutions.

Fichier JSON	Objectif de configuration	Accès aux fichiers
tasks.vs.json	Définissez des commandes de génération personnalisées, des commutateurs de compilation personnalisés ainsi que des tâches arbitraires (non liées à la génération).	Dans Explorateur de solutions, cliquez avec le bouton droit sur un fichier ou un dossier pour ouvrir le menu contextuel, puis sélectionnez Configurer les tâches.
launch.vs.json	Spécifiez les arguments de ligne de commande pour le débogage.	Dans Explorateur de solutions, cliquez avec le bouton droit sur un fichier ou un dossier pour ouvrir le menu contextuel, puis sélectionnez Ajouter une configuration Debug.

Ajouter des fichiers JSON au contrôle de code source

Par défaut, les fichiers JSON tasks et launch ne sont pas visibles dans Explorateur de solutions. Ils se trouvent dans un dossier masqué appelé .vs dans le dossier racine (\) de votre codebase. Les fichiers sont masqués, car ils ne sont pas couramment ajoutés au contrôle de code source. Vous pouvez afficher les fichiers masqués dans Visual Studio en sélectionnant l’option Afficher tous les fichiers dans Explorateur de solutions.

Si vous souhaitez ajouter les fichiers JSON au contrôle de code source, faites glisser les fichiers vers le dossier racine (\) de votre codebase dans votre système de fichiers. Les fichiers deviennent visibles dans Explorateur de solutions et disponibles pour le contrôle de code source.

Définir de tâches avec tasks.vs.json

Vous pouvez automatiser les scripts de génération et les opérations externes sur les fichiers de votre espace de travail actuel en exécutant les actions comme des tâches directement dans Visual Studio. Pour configurer une nouvelle tâche, cliquez avec le bouton droit sur un fichier ou un dossier dans Explorateur de solutions et sélectionnez Configurer les tâches :

Cette action crée (ou ouvre) le fichier tasks.vs.json dans le dossier .vs. Vous définissez une tâche de génération ou une tâche arbitraire dans ce fichier, et Visual Studio ajoute le nom de la tâche en tant que commande au menu contextuel Explorateur de solutions. Vous pouvez appeler la tâche en sélectionnant la commande correspondante dans Explorateur de solutions.

Des tâches personnalisée peuvent être ajoutées à chaque fichier ou à l’ensemble des fichiers d’un type spécifique. Par exemple, les fichiers du package NuGet peuvent être configurés de manière à obtenir une tâche « Restaurer les packages », ou tous les fichiers sources peuvent être configurés afin d’obtenir une tâche d’analyse statique, par exemple un linter pour tous les fichiers JavaScript (.js).

Créer des tâches pour des outils non reconnus

Si votre codebase utilise des outils de génération personnalisés que Visual Studio ne reconnaît pas, vous ne pourrez pas exécuter et déboguer le code dans Visual Studio tant que vous n’aurez pas effectué des étapes de configuration supplémentaires.

Vous pouvez définir des tâches de génération pour indiquer à Visual Studio comment générer, regénérer et nettoyer votre code. Le fichier de la tâche de génération tasks.vs.json associe la boucle de développement interne de Visual Studio aux outils de génération personnalisée utilisés par le codebase.

Supposons que votre codebase possède un seul fichier C# nommé hello.cs. Le fichier makefile d’un tel codebase pourrait se présenter comme ceci :

build: directory hello.exe

hello.exe: hello.cs
    csc -debug hello.cs /out:bin\hello.exe

clean:
    del bin\hello.exe bin\hello.pdb

rebuild: clean build

directory: bin

bin:
    md bin

Pour un makefile similaire qui contient des cibles de génération, de nettoyage et de regénération, vous pouvez utiliser l’option Configurer les tâches pour le makefile et définir le fichier tasks.vs.json suivant. Le fichier JSON définit des tâches pour générer, regénérer et nettoyer le codebase à l’aide de NMAKE comme outil de génération :

{
  "version": "0.2.1",
  "outDir": "\"${workspaceRoot}\\bin\"",
  "tasks": [
    {
      "taskName": "makefile-build",
      "appliesTo": "makefile",
      "type": "launch",
      "contextType": "build",
      "command": "nmake",
      "args": [ "build" ],
      "envVars": {
        "VSCMD_START_DIR": "\"${workspaceRoot}\""
      }
    },
    {
      "taskName": "makefile-clean",
      "appliesTo": "makefile",
      "type": "launch",
      "contextType": "clean",
      "command": "nmake",
      "args": [ "clean" ],
      "envVars": {
        "VSCMD_START_DIR": "\"${workspaceRoot}\""
      }
    },
    {
      "taskName": "makefile-rebuild",
      "appliesTo": "makefile",
      "type": "launch",
      "contextType": "rebuild",
      "command": "nmake",
      "args": [ "rebuild" ],
      "envVars": {
        "VSCMD_START_DIR": "\"${workspaceRoot}\""
      }
    }
  ]
}

Une fois que vous avez défini les tâches de génération dans le fichier tasks.vs.json, Visual Studio ajoute les commandes de tâche correspondantes au menu contextuel dans Explorateur de solutions. Dans cet exemple, les options de génération, regénération et nettoyage sont ajoutées au menu contextuel pour les instances de makefile dans le codebase :

Visual Studio répertorie les nouvelles commandes dans le menu contextuel après la commande Configurer les tâches en fonction de leurs paramètres contextType. « build », « rebuild » et « clean » sont les commandes de génération et sont répertoriées dans la section « Générer » du menu contextuel.

Lorsque vous sélectionnez une commande de tâche personnalisée dans le menu contextuel, l’opération s’exécute. Visual Studio affiche la sortie de commande dans la fenêtre Sortie et toutes les erreurs de génération dans la Liste des erreurs.

Créer des tâches pour des opérations arbitraires

Vous pouvez définir des tâches personnalisées dans le fichier tasks.vs.json pour toute opération arbitraire. Vous pouvez définir une tâche afin d’afficher le nom du fichier actuellement sélectionné dans la fenêtre Sortie ou lister les fichiers d’un dossier spécifié.

Exemple : afficher le nom du fichier actuellement sélectionné

L’exemple suivant montre un fichier tasks.vs.json qui définit une tâche arbitraire unique. Lorsque vous appelez cette tâche, l’opération affiche le nom de fichier du fichier JavaScript (.js) actuellement sélectionné.

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskName": "Echo filename",
      "appliesTo": "*.js",
      "type": "default",
      "command": "${env.COMSPEC}",
      "args": [ "echo ${file}" ]
    }
  ]
}

Le code de cette tâche définit les propriétés suivantes :

• taskName : nom de la commande de tâche pour Visual Studio à afficher dans le menu contextuel. Dans ce cas, Echo filename.
• appliesTo : fichiers sur lesquels la commande de tâche doit agir. Dans ce cas, les fichiers JavaScript (.js).
• command : commande à appeler. Cette tâche utilise la variable d’environnement COMSPEC pour identifier l’interpréteur de ligne de commande (en général cmd.exe).
• args : tous les arguments à passer lorsque Visual Studio appelle la commande.
• ${file} : les arguments de cette tâche incluent une macro qui récupère le fichier actuellement sélectionné dans Explorateur de solutions.

Après avoir enregistré le fichier tasks.vs.json, vous pouvez cliquer avec le bouton droit de la souris sur n’importe quel fichier JavaScript (.js) dans le dossier et sélectionner Echo filename. Visual Studio affiche le nom de fichier sélectionné dans la fenêtre Sortie.

Exemple : lister les fichiers et les sous-dossiers

L’exemple suivant montre un fichier tasks.vs.json qui définit une tâche pour lister les fichiers et les sous-dossiers du dossier bin :

{
  "version": "0.2.1",
  "outDir": "\"${workspaceRoot}\\bin\"",
  "tasks": [
    {
      "taskName": "List Outputs",
      "appliesTo": "*",
      "type": "default",
      "command": "${env.COMSPEC}",
      "args": [ "dir ${outDir}" ]
    }
  ]
}

Le code de cette tâche définit les propriétés suivantes :

• taskName : nom de la commande de tâche pour le menu contextuel, List Outputs.
• appliesTo : cette tâche agit sur tous les éléments du dossier spécifié, comme indiqué par l’utilisation du caractère générique (*).
• command : comme dans l’exemple précédent, la tâche utilise la variable d’environnement COMSPEC pour identifier l’interpréteur de ligne de commande (cmd.exe).
• args : lorsque Visual Studio appelle la tâche, il passe un appel à la commande dir, qui liste les éléments du répertoire (dossier).
• ${outDir} : la macro {outDir} est définie avant le bloc tasks. Elle identifie le dossier bin comme répertoire sur lequel agir.

Cette tâche s’applique à tous les fichiers du codebase. Lorsque Visual Studio ajoute le nom de commande d’une tâche arbitraire au menu contextuel, il ajoute à la commande le préfixe Run, comme dans Run List Outputs.

Si vous ouvrez le menu contextuel d’un fichier dans Explorateur de solutions, la commande Run List Outputs de liste de tâches s’affiche comme dernière commande dans la section « Générer » du menu. Lorsque vous sélectionnez Run List Outputs, Visual Studio répertorie le contenu du dossier bin pour le codebase dans la fenêtre Sortie :

Utiliser plusieurs fichiers task.vs.json

Vous pouvez avoir plusieurs fichiers tasks.vs.json dans le dossier racine (\) et les sous-dossiers de votre codebase. Cette approche vous donne la possibilité de définir un comportement différent pour des sous-dossiers ou des fichiers spécifiques dans votre codebase.

Visual Studio regroupe ou substitue les paramètres dans l’ensemble du codebase, en priorisant les fichiers selon l’ordre suivant :

1. Fichiers de paramètres dans le dossier .vs dans le dossier racine (\).
2. Dossier dans lequel un paramètre est calculé.
3. Dossier parent du dossier actif, jusqu’au dossier racine (\).
4. Les fichiers de paramètres dans le dossier racine (\).

Ces règles d’agrégation s’appliquent uniquement aux instances du fichier tasks.vs.json.

Examiner les propriétés de tasks.vs.json

Les sections suivantes décrivent certaines des propriétés que vous pouvez spécifier dans un fichier tasks.vs.json.

Définir la propriété appliesTo

Vous pouvez créer des tâches pour n’importe quel fichier ou dossier en spécifiant le nom du fichier ou du dossier avec la propriété appliesTo, par exemple "appliesTo": "hello.js".

Le tableau suivant récapitule les valeurs de masque de fichier que vous pouvez utiliser avec la propriété appliesTo pour produire un comportement de tâche spécifique :

Valeur (masque de fichier)	La tâche s'applique à
"*"	Tous les fichiers et dossiers de l’espace de travail
"*/"	Toutes les dossiers de l’espace de travail
"*.js"	Tous les fichiers avec l’extension JavaScript (.js) dans l’espace de travail
"/*.js"	Tous les fichiers avec l’extension JavaScript (.js) dans le dossier racine (\) de l’espace de travail
"src/*/"	Tous les sous-dossiers du dossier src
"makefile"	Tous les fichiers nommés makefile dans l’espace de travail
"/makefile"	Seul le fichier nommé makefile dans le dossier racine (\) de l’espace de travail

Utiliser des macros dans les arguments de tâche

Vous pouvez passer des macros en tant qu’arguments pour une tâche afin d’améliorer le comportement de la tâche lorsque Visual Studio appelle la commande.

Des exemples de macro sont répertoriés dans le tableau suivant :

Macro	Description	Exemples
${env.<VARIABLE>}	Spécifie toute variable d’environnement utilisable dans l’invite de commandes développeur. Pour plus d’informations, consultez Invite de commandes développeur et Developer PowerShell.	${env.PATH}, ${env.COMSPEC}
${workspaceRoot}	Fournit le chemin complet du dossier de l’espace de travail.	C:\sources\hello, C:\sources\hello\bin
${file}	Fournit le chemin complet du fichier ou dossier.	C:\sources\hello\src\hello.js*, C:\sources\hello\src\test.js*
${relativeFile}	Fournit le chemin relatif du fichier ou dossier.	src\hello.js*, bin\hello.exe
${fileBasename}	Fournit le nom du fichier, sans le chemin d’accès ou l’extension.	hello, test
${fileDirname}	Fournit le chemin complet du fichier, sans le nom de fichier.	C:\sources\hello\src*, C:\sources\hello\bin\test\*
${fileExtname}	Fournit l’extension du fichier sélectionné.	.js, .cs, .exe

Configurer le débogage avec launch.vs.json

Visual Studio fournit un fichier launch.vs.json que vous pouvez utiliser pour configurer le débogage pour votre codebase.

Remarque

Pour configurer des projets CMake pour le débogage, consultez Configurer les sessions de débogage CMake.

1. Dans Explorateur de solutions, cliquez avec le bouton droit sur un fichier exécutable (.exe) et sélectionnez Ajouter une configuration de débogage :

   

2. Dans la boîte de dialogue Sélectionner un débogueur , sélectionnez une option de configuration de débogage dans la liste, puis choisissez Sélectionner :

   

   Si le fichier launch.vs.json n’existe pas déjà, Visual Studio le crée. Voici un exemple de fichier créé pour l’exécutable hello.exe :

   {
     "version": "0.2.1",
     "defaults": {},
     "configurations": [
       {
         "type": "default",
         "project": "bin\\hello.exe",
         "projectTarget": "",
         "name": "hello.exe"
       }
     ]
   }
   

3. Une fois que vous avez un fichier launch, cliquez avec le bouton droit sur le fichier exécutable de votre codebase dans Explorateur de solutions, puis sélectionnez Définir comme élément de démarrage.

   Le fichier exécutable est désigné comme élément de démarrage pour votre codebase, et Visual Studio définit le libellé du bouton Démarrer du mode débogage pour refléter le nom de votre fichier exécutable :

   

   Lorsque vous démarrez le débogueur avec F5, Visual Studio démarre le débogage de votre code et s’arrête à n’importe quel point d’arrêt défini. Toutes les fenêtres du débogueur habituelles sont disponibles et opérationnelles.

   Pour plus d’informations sur les tâches de génération et de débogage personnalisées dans les projets de dossiers ouverts C++, consultez Prise en charge des dossiers ouverts pour les systèmes de génération C++ dans Visual Studio.

Spécifier des arguments pour le débogage

Vous pouvez spécifier des arguments de ligne de commande à passer au débogueur dans le fichier launch.vs.json. Ajoutez les arguments au tableau args, comme indiqué dans l’exemple suivant :

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "default",
      "project": "bin\\hello.exe",
      "name": "hello.exe"
    },
    {
      "type": "default",
      "project": "bin\\hello.exe",
      "name": "hello.exe a1",
      "args": [ "a1" ]
    }
  ]
}

Lancer une configuration de débogage

Vous pouvez créer autant de configurations de débogage que vous le souhaitez. Lorsque vous enregistrez le fichier launch, les noms de configuration sont ajoutés à la liste déroulante Cible de débogage. Vous pouvez sélectionner une cible spécifique pour démarrer le débogueur :

Si vous ne voyez pas les cibles supplémentaires dans le menu, sélectionnez Afficher/Masquer des cibles de débogage et configurez les cibles visibles.

Comprendre la priorité des configurations

Visual Studio analyse deux emplacements pour les éléments spécifiés dans la propriété de tableau configurations dans les fichiers launch.vs.json :

• Dossier racine (\) pour le codebase
• Le dossier .vs

Si vous avez des fichiers launch.vs.json dans les deux emplacements et qu’il existe un conflit dans la définition d’une configuration, la valeur dans le fichier .vs\launch.vs.json est prioritaire.

Utiliser d’autres fichiers de paramètres

Outre les fichiers JSON task et launch, Visual Studio lit les paramètres d’autres fichiers de configuration définis dans votre codebase. settings.json et .gitignore sont deux exemples de fichiers couramment utilisés.

Définir des paramètres de code avec .vscode\settings.json

Visual Studio lit les paramètres limités à partir d’un fichier nommé settings.json, lorsque le fichier se trouve dans un dossier nommé .vscode.

Cette fonctionnalité est fournie pour les codebases qui ont déjà été développés dans Visual Studio Code. Actuellement, le seul paramètre lu à partir du fichier .vscode\settings.json est files.exclude. Ce paramètre est utilisé pour filtrer visuellement les fichiers dans Explorateur de solutions et à partir de certains outils de recherche.

Votre codebase peut comporter plusieurs fichiers .vscode\settings.json. Les paramètres lus à partir de ce fichier sont appliqués au dossier parent de .vscode et à tous ses sous-dossiers.

Configurer des fichiers Git avec .gitignore

Vous pouvez utiliser un fichier .gitignore pour indiquer à Git quels fichiers ignorer lors de l’application du contrôle de code source. Les fichiers .gitignore font généralement partie d’un codebase afin de pouvoir partager les paramètres avec tous les développeurs du codebase. Visual Studio lit les schémas dans les fichiers .gitignore pour filtrer les éléments visuellement à partir de certains outils de recherche.

Les paramètres lus à partir du fichier .gitignore sont appliqués à son dossier parent et à tous les sous-dossiers.

Contenu connexe

• Développer du code sans projets ni solutions
• Projets Dossier ouvert pour C++
• Explorer les fonctionnalités de l’éditeur de code