Personnaliser des tâches de génération et de débogage pour le développement « Ouvrir le dossier »Customize build and debug tasks for "Open Folder" development

Visual Studio sait comment exécuter de nombreux langages et codes de base, mais il ne sait pas comment exécuter tous les éléments.Visual Studio knows how to run many different languages and codebases, but it doesn't know how to run everything. Si vous avez ouvert un dossier de code dans Visual Studio et que Visual Studio sait comment exécuter votre code, vous pouvez l’exécuter immédiatement sans aucune configuration supplémentaire.If you opened a code folder in Visual Studio, and Visual Studio knows how to run your code, you can run it right away without any additional configuration.

Si le code base utilise des outils de génération personnalisés que Visual Studio ne reconnaît pas, vous devez fournir des détails de configuration pour exécuter et déboguer le code dans Visual Studio.If the codebase uses custom build tools that Visual Studio doesn't recognize, you need to provide some configuration details to run and debug the code in Visual Studio. Vous indiquez à Visual Studio comment générer votre code en définissant des tâches de génération.You instruct Visual Studio how to build your code by defining build tasks. Vous pouvez créer une ou plusieurs tâches de génération pour spécifier tous les éléments dont un langage a besoin pour générer et exécuter son code.You can create one or more build tasks to specify all the items a language needs to build and run its code. Vous pouvez également créer des tâches arbitraires qui peuvent faire pratiquement tout ce que vous souhaitez.You can also create arbitrary tasks that can do nearly anything you want. Par exemple, vous pouvez créer une tâche visant à répertorier le contenu d’un dossier ou à renommer un fichier.For example, you can create a task to list the contents of a folder or to rename a file.

Personnalisez votre code base sans projet en utilisant les fichiers .json suivants :Customize your project-less codebase by using the following .json files:

Nom de fichierFile name ObjectifPurpose
tasks.vs.jsontasks.vs.json Spécifiez des commandes de génération personnalisée, des commutateurs de compilation ainsi que des tâches arbitraires (non liées à la génération).Specify custom build commands and compiler switches, and arbitrary (non-build related) tasks.
Accessible via l’option Configurer les tâches du menu contextuel de l’Explorateur de solutions.Accessed via the Solution Explorer context menu item Configure Tasks.
launch.vs.jsonlaunch.vs.json Spécifiez les arguments de ligne de commande pour le débogage.Specify command-line arguments for debugging.
Accessible via l’option Paramètres de débogage et de lancement du menu contextuel de l’Explorateur de solutions.Accessed via the Solution Explorer context menu item Debug and Launch Settings.
VSWorkspaceSettings.jsonVSWorkspaceSettings.json Paramètres génériques qui peuvent avoir un impact sur les tâches et le lancement.Generic settings that may impact tasks and launch. Par exemple, définir envVars dans VSWorkspaceSettings.json ajoute les variables d’environnement spécifiées pour exécuter des commandes en externe.For example, defining envVars in VSWorkspaceSettings.json adds the specified environment variables to externally run commands.
Vous créez ce fichier manuellement.You create this file manually.

Ces fichiers .json se trouvent dans un dossier masqué appelé .vs dans le dossier racine de votre code base.These .json files are located in a hidden folder called .vs in the root folder of your codebase. Les fichiers tasks.vs.json et launch.vs.json sont créés par Visual Studio selon les besoins lorsque vous choisissez l’option Configurer les tâches ou Paramètres de débogage et de lancement pour un fichier ou dossier dans l’Explorateur de solutions.The tasks.vs.json and launch.vs.json files are created by Visual Studio on an as-needed basis when you choose either Configure Tasks or Debug and Launch Settings on a file or folder in Solution Explorer. Les fichiers .json sont masqués car les utilisateurs ne souhaitent généralement pas les vérifier dans le contrôle de code source.These .json files are hidden because users generally don't want to check them into source control. Toutefois, si vous souhaitez être en mesure de les vérifier dans le contrôle de code source, faites glisser les fichiers à la racine de votre code base, où ils sont visibles.However, if you want to be able to check them into source control, drag the files into the root of your codebase, where they are visible.

Conseil

Pour voir les fichiers masqués dans Visual Studio, cliquez sur le bouton Afficher tous les fichiers de la barre d’outils de l’Explorateur de solutions.To view hidden files in Visual Studio, choose the Show All Files button on the Solution Explorer toolbar.

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

Vous pouvez automatiser les scripts de génération ou d’autres opérations externes sur les fichiers de votre espace de travail actuel en les exécutant comme des tâches directement dans l’IDE.You can automate build scripts or any other external operations on the files you have in your current workspace by running them as tasks directly in the IDE. Vous pouvez configurer une nouvelle tâche en cliquant sur un fichier ou dossier puis en sélectionnant Configurer les tâches.You can configure a new task by right-clicking on a file or folder and selecting Configure Tasks.

Configurer le menu Tâches

Permet de créer (ou d’ouvrir) le fichier tasks.vs.json dans le dossier .vs.This creates (or opens) the tasks.vs.json file in the .vs folder. Vous pouvez définir une tâche de génération ou une tâche arbitraire dans ce fichier, puis l’appeler en utilisant le nom que vous lui avez attribué à l’aide du menu contextuel de l’Explorateur de solutions.You can define a build task or arbitrary task in this file, and then invoke it using the name you gave it from the Solution Explorer context menu.

Des tâches personnalisée peuvent être ajoutées à chaque fichier ou à l’ensemble des fichiers d’un type spécifique.Custom tasks can be added to individual files, or to all files of a specific type. 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 .js.For instance, NuGet package files can be configured to have a "Restore Packages" task, or all source files can be configured to have a static analysis task, such as a linter for all .js files.

Définir des tâches de génération personnaliséesDefine custom build tasks

Si votre code base 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é certaines étapes de configuration.If your codebase uses custom build tools that Visual Studio doesn't recognize, then you cannot run and debug the code in Visual Studio until you complete some configuration steps. Visual Studio fournit des tâches de génération dans lesquelles vous pouvez indiquer à Visual Studio comment générer, regénérer et nettoyer votre code.Visual Studio provides build tasks where you can tell Visual Studio how to build, rebuild, and clean your 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 code de base.The tasks.vs.json build task file couples the Visual Studio inner development loop to the custom build tools used by your codebase.

Prenons un code base composé d’un seul fichier cC# appelé hello.cs.Consider a codebase that consists of a single C# file called hello.cs. Le fichier makefile d’un tel code base pourrait se présenter comme ceci :The makefile for such a codebase might look like this:

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 ce fichier makefile contenant des cibles de génération, de nettoyage et de regénération, vous pouvez définir le fichier tasks.vs.json suivant.For such a makefile that contains build, clean, and rebuild targets, you can define the following tasks.vs.json file. Il contient trois tâches pour la génération, la régénération et le nettoyage du code base, en utilisant NMAKE comme outil de génération.It contains three build tasks for building, rebuilding, and cleaning the codebase, using NMAKE as the build tool.

{
  "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}\""
      }
    }
  ]
}

Après avoir défini les tâches de génération dans tasks.vs.json, d’autres éléments de menu contextuel sont ajoutés aux fichiers correspondants dans l’Explorateur de solutions.After you define build tasks in tasks.vs.json, additional context menu items are added to the corresponding files in Solution Explorer. Pour cet exemple, les options « Générer », « Regénérer » et « Nettoyer » sont ajoutées au menu contextuel des fichiers makefile.For this example, "build", "rebuild", and "clean" options are added to the context menu of any makefile files.

menu contextuel makefile avec générer, régénerer et nettoyer

Note

Les commandes apparaissent dans le menu contextuel, sous la commande Configurer les tâches en raison de leurs paramètres contextType.The commands appear in the context menu under the Configure Tasks command due to their contextType settings. Les commandes « générer », « régénérer » et « nettoyer » étant des commandes de génération, elles apparaissent dans la section de génération au milieu du menu contextuel."build", "rebuild", and "clean" are build commands, so they appear in the build section in the middle of the context menu.

Lorsque vous sélectionnez une de ces options, la tâche s’exécute.When you select one of these options, the task executes. La sortie s’affiche dans la fenêtre Sortie et les erreurs de génération apparaissent dans la liste d’erreurs.Output appears in the Output window, and build errors appear in the Error List.

Définir des tâches arbitrairesDefine arbitrary tasks

Vous pouvez définir des tâches arbitraires dans le fichier tasks.vs.json et faire ainsi à peu près tout ce que vous voulez.You can define arbitrary tasks in the tasks.vs.json file, to do just about anything you want. Par exemple, vous pouvez définir une tâche afin d’afficher le nom du fichier actuellement sélectionné dans la fenêtre Sortie, ou pour répertorier les fichiers d’un répertoire spécifié.For example, you can define a task to display the name of the currently selected file in the Output window, or to list the files in a specified directory.

L’exemple suivant montre un fichier tasks.vs.json qui définit une tâche unique.The following example shows a tasks.vs.json file that defines a single task. Lorsqu’elle est appelée, la tâche affiche le nom de fichier de fichier .js actuellement sélectionné.When invoked, the task displays the filename of the currently selected .js file.

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskName": "Echo filename",
      "appliesTo": "*.js",
      "type": "default",
      "command": "${env.COMSPEC}",
      "args": [ "echo ${file}" ]
    }
  ]
}
  • taskName spécifie le nom qui apparaît dans le menu contextuel.taskName specifies the name that appears in the context menu.
  • appliesTo spécifie les fichiers que lesquels la commande peut être exécutée.appliesTo specifies which files the command can be performed on.
  • La propriété command spécifie la commande à appeler.The command property specifies the command to invoke. Dans cet exemple, la variable d’environnement COMSPEC sert à identifier l’interpréteur de ligne de commande, en général cmd.exe.In this example, the COMSPEC environment variable is used to identify the command line interpreter, typically cmd.exe.
  • La propriété args spécifie les arguments à passer à la commande appelée.The args property specifies the arguments to be passed to the invoked command.
  • La macro ${file} extrait le fichier sélectionné dans l’Explorateur de solutions.The ${file} macro retrieves the selected file in Solution Explorer.

Après avoir enregistré tasks.vs.json, vous pouvez cliquer avec le bouton droit sur n’importe quel fichier .js dans le dossier, puis choisir Echo nomfichier.After saving tasks.vs.json, you can right-click on any .js file in the folder and choose Echo filename. Le nom de fichier apparaît dans la fenêtre Sortie .The file name is displayed in the Output window.

Note

Si votre code base ne contient aucun fichier tasks.vs.json, vous pouvez en créer un en choisissant l’élément de menu contextuel Configurer les tâches en cliquant avec le bouton droit sur un fichier dans l’Explorateur de solutions.If your codebase doesn't contain a tasks.vs.json file, you can create one by choosing Configure Tasks from the right-click or context menu of a file in Solution Explorer.

L’exemple suivant définit une tâche qui répertorie les fichiers et sous-dossiers du répertoire bin.The next example defines a task that lists the files and subfolders of the bin directory.

{
  "version": "0.2.1",
  "outDir": "\"${workspaceRoot}\\bin\"",
  "tasks": [
    {
      "taskName": "List Outputs",
      "appliesTo": "*",
      "type": "default",
      "command": "${env.COMSPEC}",
      "args": [ "dir ${outDir}" ]
    }
  ]
}
  • ${outDir} est une macro personnalisée qui est d’abord définie avant le bloc tasks.${outDir} is a custom macro that is first defined before the tasks block. Elle est ensuite appelée dans la propriété args.It is then called in the args property.

Cette tâche s’applique à tous les fichiers.This task applies to all files. Lorsque vous ouvrez le menu contextuel de n’importe quel fichier dans l’Explorateur de solutions, le nom de la tâche Répertorier les sorties apparaît au bas du menu.When you open the context menu on any file in Solution Explorer, the task's name List Outputs appears at the bottom of the menu. Lorsque vous choisissez Répertorier les sorties, le contenu du répertoire bin est répertorié dans la fenêtre Sortie de Visual Studio.When you choose List Outputs, the contents of the bin directory are listed in the Output window in Visual Studio.

Tâche arbitraire dans le menu contextuel

Portée des paramètresSettings scope

Plusieurs fichiers tasks.vs.json peuvent exister à la racine et les sous-répertoires d’un code base.Multiple tasks.vs.json files can exist at the root and subdirectories of a codebase. Cette conception offre la flexibilité de pouvoir bénéficier d’un comportement différent dans les divers sous-répertoires du code base.This design enables the flexibility to have different behavior in different subdirectories of the codebase. Visual Studio regroupe ou substitue les paramètres dans l’ensemble du code base, en hiérarchisation les fichiers dans l’ordre suivant :Visual Studio aggregates or overrides settings throughout the codebase, prioritizing files in the following order:

  • Les fichiers de paramètres dans le dossier racine du répertoire .vs.Settings files in the root folder’s .vs directory.
  • Le répertoire dans lequel un paramètre est calculé.The directory where a setting is being computed.
  • Le répertoire parent du répertoire actuel, jusqu'au répertoire racine.The current directory’s parent directory, all the way up to the root directory.
  • Les fichiers de paramètres dans le dossier racine.Settings files in the root directory.

Ces règles d’agrégation s’appliquent aux fichiers tasks.vs.json et VSWorkspaceSettings.json.These aggregation rules apply to tasks.vs.json and VSWorkspaceSettings.json files. Pour plus d’informations sur la façon dont les paramètres d’un autre fichier sont agrégés, consultez la section correspondante à ce fichier dans cet article.For information on how settings in other file are aggregated, see the corresponding section for that file in this article.

Propriétés de tasks.vs.jsonProperties for tasks.vs.json

Cette section décrit certaines des propriétés que vous pouvez spécifier dans tasks.vs.json.This section describes some of the properties you can specify in tasks.vs.json.

appliesToappliesTo

Vous pouvez créer des tâches pour tout fichier ou dossier en spécifiant son nom dans le champ appliesTo, par exemple "appliesTo": "hello.js".You can create tasks for any file or folder by specifying its name in the appliesTo field, for example "appliesTo": "hello.js". Les masques de fichier suivants peuvent être utilisés comme valeurs :The following file masks can be used as values:

"*" la tâche est disponible pour tous les fichiers et dossiers dans l’espace de travailtask is available to all files and folders in the workspace
"*/" la tâche est disponible pour tous les dossiers dans l’espace de travailtask is available to all folders in the workspace
"*.js" la tâche est disponible pour tous les fichiers avec l’extension .js dans l’espace de travailtask is available to all files with the extension .js in the workspace
"/*.js" la tâche est disponible pour tous les fichiers avec l’extension .js à la racine de l’espace de travailtask is available to all files with the extension .js in the root of the workspace
"src/*/" la tâche est disponible pour tous les sous-dossiers du dossier srctask is available to all subfolders of the src folder
"makefile" la tâche est disponible pour tous les fichiers makefile dans l’espace de travailtask is available to all makefile files in the workspace
"/makefile" la tâche est disponible seulement dans le fichier makefile à la racine de l’espace de travailtask is available only to the makefile in the root of the workspace

Macros pour tasks.vs.jsonMacros for tasks.vs.json

${env.<VARIABLE>} Spécifie toute variable d’environnement (par exemple, ${env.PATH}, ${env.COMSPEC}, etc.) définie pour l’invite de commandes développeur.Specifies any environment variable (for example, ${env.PATH}, ${env.COMSPEC} and so on) that is set for the developer command prompt. Pour plus d’informations, consultez Invite de commandes développeur pour Visual Studio.For more information, see Developer command prompt for Visual Studio.
${workspaceRoot} Le chemin complet vers le dossier de l’espace de travail (par exemple C:\sources\hello)The full path to the workspace folder (for example, C:\sources\hello)
${file} Le chemin complet du fichier ou du dossier sur lequel exécuter cette tâche (par exemple C:\sources\hello\src\hello.js)The full path of the file or folder selected to run this task against (for example, C:\sources\hello\src\hello.js)
${relativeFile} Le chemin relatif du fichier ou du dossier (par exemple src\hello.js)The relative path to the file or folder (for example, src\hello.js)
${fileBasename} Le nom du fichier sans chemin ni extension (par exemple hello)The name of the file without path or extension (for example, hello)
${fileDirname} Le chemin complet du fichier, sans le nom de fichier (par exemple C:\sources\hello\src)The full path to the file, excluding the filename (for example, C:\sources\hello\src)
${fileExtname} L’extension du fichier sélectionné (par exemple .js)The extension of the selected file (for example, .js)

Configurer le débogage avec launch.vs.jsonConfigure debugging with launch.vs.json

  1. Afin de configurer votre code base pour le débogage, dans l’Explorateur de solutions choisissez l’élément de menu contextuel Paramètres de débogage et de lancement en cliquant avec le bouton droit sur votre fichier exécutable.To configure your codebase for debugging, in Solution Explorer choose the Debug and Launch Settings menu item from the right-click or context menu of your executable file.

    Menu contextuel Paramètres de débogage et de lancement

  2. Dans la boîte de dialogue Sélectionner un débogueur, choisissez une option, puis cliquez sur le bouton Sélectionner.In the Select a Debugger dialog box, choose an option, and then choose the Select button.

    Sélectionner une boîte de dialogue de débogueur

    Si le fichier launch.vs.json n’existe pas déjà, il est créé.If the launch.vs.json file doesn't already exist, it is created.

    {
      "version": "0.2.1",
      "defaults": {},
      "configurations": [
        {
          "type": "default",
          "project": "bin\\hello.exe",
          "name": "hello.exe"
        }
      ]
    }
    
  3. Cliquez ensuite avec le bouton droit sur le fichier exécutable dans l'Explorateur de solutions, puis choisissez Définir comme élément de démarrage.Next, right-click on the executable file in Solution Explorer, and choose Set as Startup Item.

    Le fichier exécutable est désigné comme élément de démarrage pour votre code base, et l’intitulé du bouton Démarrer du mode débogage change pour refléter le nom de votre fichier exécutable.The executable is designated as the startup item for your codebase, and the debugging Start button's title changes to reflect the name of your executable.

    Bouton Démarrer personnalisé

    Lorsque vous choisissez F5, le débogueur démarre et s’arrête au point d’arrêt que vous avez déjà défini.When you choose F5, the debugger launches and stops at any breakpoint you may have already set. Toutes les fenêtres du débogueur habituelles sont disponibles et opérationnelles.All the familiar debugger windows are available and functional.

Spécifier des arguments pour le débogageSpecify arguments for debugging

Vous pouvez spécifier des arguments de ligne de commande à passer pour le débogage dans le fichier launch.vs.json.You can specify command-line arguments to pass in for debugging in the launch.vs.json file. Ajoutez les arguments au tableau args, comme indiqué dans l’exemple suivant :Add the arguments in the args array, as shown in the following example:

{
  "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" ]
    }
  ]
}

Lorsque vous enregistrez ce fichier, le nom de la nouvelle configuration apparaît dans le menu déroulant cible de débogage, et vous pouvez le sélectionner pour démarrer le débogueur.When you save this file, the name of the new configuration appears in the debug target drop-down list, and you can select it to start the debugger. Vous pouvez créer autant de configurations de débogage que vous le souhaitez.You can create as many debug configurations as you like.

Liste déroulante des configurations de débogage

Note

La propriété de tableau configurations dans launch.vs.json est lue à partir de deux emplacements de fichiers—le répertoire racine du code base et le répertoire .vs.The configurations array property in launch.vs.json is read from two file locations—the root directory for the codebase, and the .vs directory. En cas de conflit, la priorité est donnée à la valeur dans .vs\launch.vs.json.If there is a conflict, priority is given to the value in .vs\launch.vs.json.

Définir les paramètres de l’espace de travail dans VSWorkspaceSettings.jsonDefine workspace settings in VSWorkspaceSettings.json

Vous pouvez spécifier des paramètres génériques qui peuvent avoir un impact sur les tâches et le lancement dans le fichier VSWorkspaceSettings.json.You can specify generic settings that may impact tasks and launch in the VSWorkspaceSettings.json file. Par exemple, si vous définissez envVars dans VSWorkspaceSettings.json, Visual Studio ajoute les variables d’environnement spécifiées aux commandes exécutées de façon externe.For example, if you define envVars in VSWorkspaceSettings.json, Visual Studio adds the specified environment variables to commands that are run externally. Pour utiliser ce fichier, vous devez le créer manuellement.To use this file, you must create it manually.

Autres fichiers de paramètresAdditional settings files

Outre les trois fichiers .json décrits dans cette rubrique, Visual Studio lit également les paramètres de certains autres fichiers, s’ils existent dans votre code base.In addition to the three .json files described in this topic, Visual Studio also reads settings from some additional files, if they exist in your codebase.

.vscode\settings.json.vscode\settings.json

Visual Studio lit les paramètres limités d’un fichier nommé settings.json si celui-ci se trouve dans un répertoire nommé .vscode.Visual Studio reads limited settings from a file named settings.json, if it is in a directory named .vscode. Cette fonctionnalité est fournie pour les codes base qui ont déjà été développés dans Visual Studio Code.This functionality is provided for codebases that have previously been developed in Visual Studio Code. Actuellement, le seul paramètre lu à partir de .vscode\settings.json est files.exclude, qui filtre les fichiers visuellement dans l’Explorateur de solutions et de certains outils de recherche.Currently, the only setting that is read from .vscode\settings.json is files.exclude, which filters files visually in Solution Explorer and from some search tools.

Votre code base peut comporter n’importe quel nombre de fichiers .vscode\settings.json.You can have any number of .vscode\settings.json files in your codebase. Les paramètres lus à partir de ce fichier sont appliqués au répertoire parent de .vscode et à tous ses sous-répertoires.Settings read from this file are applied to the parent directory of .vscode and all of its subdirectories.

.gitignore.gitignore

Les fichiers .gitignore sont utilisés pour indiquer à Git quels fichiers ignorer, c’est-à-dire les fichiers et les répertoires que vous ne souhaitez pas archiver..gitignore files are used to tell Git which files to ignore; that is, which files and directories you don't want to check in. Les fichiers .gitignore font généralement partie d’un code base afin de pouvoir partager les paramètres avec tous les développeurs du code base..gitignore files are usually included as part of a codebase so that the settings can be shared with all developers of the codebase. Visual Studio lit les schémas dans les fichiers .gitignore pour filtrer les éléments visuellement à partir de certains outils de recherche.Visual Studio reads patterns in .gitignore files to filter items visually and from some search tools.

Les paramètres lus à partir du fichier .gitignore sont appliqués à son répertoire parent et à tous les sous-répertoires.Settings read from the .gitignore file are applied to its parent directory and all subdirectories.

Voir aussiSee also