Criar tarefas de compilação e depuração para desenvolvimento de "Pasta Aberta"

O Visual Studio pode executar automaticamente muitas linguagens de programação e bases de código diferentes. A opção Abrir Pasta permite executar imediatamente o código para uma base de código reconhecida sem instruções especiais e sem criar um projeto. Os desenvolvedores geralmente usam essa abordagem para teste rápido.

Algumas bases de código requerem ferramentas de compilação personalizadas que o Visual Studio não reconhece ou não pode processar imediatamente com a opção Abrir Pasta. Para esses cenários, você pode definir tarefas de compilação para instruir o Visual Studio sobre como compilar e depurar o código. As tarefas de compilação especificam todos os itens que uma linguagem precisa para compilar e executar o código e podem ser usadas para concluir quase todas as operações necessárias.

Este artigo descreve como definir tarefas de compilação para definir configurações de compilação e depuração para uma base de código não reconhecida e sem projeto no Visual Studio.

Explorar arquivos de configuração JSON

Para personalizar uma base de código sem projeto, o Visual Studio fornece dois arquivos JSON (.json) para definições de configuração: tasks e launch. O Visual Studio cria (ou abre) esses arquivos conforme necessário, quando você seleciona opções específicas no Gerenciador de Soluções do Visual Studio.

A tabela a seguir descreve os arquivos JSON e como criá-los no Gerenciador de Soluções.

Arquivo JSON	Finalidade da configuração	Acesso a arquivos
tasks.vs.json	Defina os comandos de compilação personalizados, as opções do compilador personalizadas, além de tarefas arbitrárias (sem relação com a compilação).	No Gerenciador de Soluções, clique com o botão direito do mouse em um arquivo ou uma pasta para abrir o menu de contexto e selecione Configurar Tarefas.
launch.vs.json	Especifica argumentos de linha de comando para depuração.	No Gerenciador de Soluções, clique com o botão direito do mouse em um arquivo ou uma pasta para abrir o menu de contexto e selecione Adicionar Configuração de Depuração.

Adicionar arquivos JSON ao controle do código-fonte

Por padrão, os arquivos JSON tasks e launch não estão visíveis no Gerenciador de Soluções. Os arquivos estão localizados em uma pasta oculta chamada .vs na pasta raiz (\) de sua base de código. Os arquivos estão ocultos porque geralmente não são adicionados ao controle do código-fonte. Você pode exibir arquivos ocultos no Visual Studio selecionando a opção Mostrar Todos os Arquivos no Gerenciador de Soluções.

Se você quiser adicionar os arquivos JSON ao controle do código-fonte, arraste os arquivos para a pasta raiz (\) da sua base de código no sistema de arquivos. Os arquivos ficam visíveis no Gerenciador de Soluções e disponíveis para o controle do código-fonte.

Definir tarefas com tasks.vs.json

Você pode automatizar os scripts de compilação e as operações externas nos arquivos em seu workspace atual, executando as ações como tarefas diretamente no Visual Studio. Para configurar uma nova tarefa, clique com o botão direito do mouse em um arquivo ou uma pasta no Gerenciador de Soluções e selecione Configurar Tarefas:

Essa ação cria (ou abre) o arquivo tasks.vs.json na pasta .vs. Você define uma tarefa de compilação ou uma tarefa arbitrária nesse arquivo, e o Visual Studio adiciona o nome da tarefa como um comando ao menu de clique com o botão direito do mouse do Gerenciador de Soluções. Você pode invocar a tarefa selecionando o comando correspondente no Gerenciador de Soluções.

As tarefas personalizadas podem ser adicionadas a arquivos individuais ou a todos os arquivos de um tipo específico. Por exemplo, os arquivos do pacote NuGet podem ser configurados para terem uma tarefa “Restaurar Pacotes” ou todos os arquivos de origem podem ser configurados para terem uma tarefa de análise estática, como um linter para todos os arquivos JavaScript (.js).

Criar tarefas para ferramentas não reconhecidas

Se a sua base de código usar ferramentas de compilação personalizadas que não são reconhecidas pelo Visual Studio, não será possível executar e depurar o código no Visual Studio antes de concluir etapas adicionais de configuração.

Você pode definir tarefas de compilação para instruir o Visual Studio sobre como compilar, recompilar e limpar seu código. O arquivo tasks.vs.json combina o loop de desenvolvimento interno do Visual Studio com as ferramentas de compilação personalizadas que você define para a base de código.

Suponha que a base de código tenha um único arquivo C# chamado hello.cs. O makefile de uma base de código como essa pode ter esta aparência:

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

Para um makefile semelhante que contém destinos de compilação, limpeza e recompilação, você pode usar a opção Configurar Tarefas para o makefile e definir o arquivo tasks.vs.json a seguir. O arquivo JSON define tarefas para compilar, recompilar e limpar a base de código usando NMAKE como a ferramenta de compilação:

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

Depois de definir tarefas de compilação no arquivo tasks.vs.json, o Visual Studio adiciona os comandos de tarefa correspondentes ao menu de clique com o botão direito do mouse no Gerenciador de Soluções. Neste exemplo, as opções Compilar, Recompilar e Limpar são adicionadas ao menu de clique com o botão direito do mouse para instâncias de makefile na base de código:

O Visual Studio lista os novos comandos no menu de clique com o botão direito do mouse após o comando Configurar Tarefas, de acordo com suas configurações de contextType. "build", "rebuild" e "clean" são comandos de Compilar e estão listados na seção "Compilar" do menu de clique com o botão direito do mouse.

Quando você seleciona um comando de tarefa personalizado no menu de clique com o botão direito do mouse, a operação é executada. O Visual Studio mostra a saída do comando na janela Saída e todos os erros de compilação na Lista de Erros.

Criar tarefas para operações arbitrárias

Você pode definir tarefas personalizadas no arquivo tasks.vs.json para qualquer operação arbitrária. Você pode definir uma tarefa para exibir o nome do arquivo selecionado atualmente na janela Saída ou para listar os arquivos em uma pasta especificada.

Exemplo: Nome de exibição do arquivo atualmente selecionado

O exemplo a seguir mostra um arquivo tasks.vs.json que define uma só tarefa arbitrária. Quando você chama essa tarefa, a operação exibe o nome do arquivo JavaScript (.js) atualmente selecionado.

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

O código para essa tarefa define as seguintes propriedades:

• taskName: o nome do comando de tarefa do Visual Studio a ser exibido no menu de clique com o botão direito do mouse. Nesse caso, Ecoar nome de arquivo.
• appliesTo: os arquivos sobre os quais o comando de tarefa deve agir. Nesse caso, arquivos JavaScript (.js).
• command: o comando a ser invocado. Essa tarefa usa a variável de ambiente COMSPEC para identificar o interpretador de linha de comando (geralmente, cmd.exe).
• args: todos os argumentos a serem passados quando o Visual Studio invoca o comando.
• ${file}: os argumentos para essa tarefa incluem uma macro que recupera o arquivo atualmente selecionado no Gerenciador de Soluções.

Depois de salvar o arquivo tasks.vs.json, você pode clicar com o botão direito do mouse em qualquer arquivo JavaScript (.js) na pasta e selecionar Ecoar nome de arquivo. O Visual Studio exibe o nome do arquivo selecionado na janela Saída.

Exemplo: Listar arquivos e subpastas

O exemplo a seguir mostra um arquivo tasks.vs.json que define uma tarefa para listar os arquivos e subpastas da pasta bin:

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

O código para essa tarefa define as seguintes propriedades:

• taskName: o nome do comando de tarefa para o menu de clique com o botão direito do mouse, Listar Saídas.
• appliesTo: esta tarefa atua em todos os itens na pasta especificada, conforme indicado pelo uso do caractere curinga (*).
• command: semelhante ao exemplo anterior, a tarefa usa a variável de ambiente COMSPEC para identificar o interpretador de linha de comando (cmd.exe).
• args: quando o Visual Studio invoca a tarefa, ele passa uma chamada para o comando dir, que lista os itens de diretório (pasta).
• ${outDir}: a macro {outDir} é definida antes do bloco tasks. Ela identifica a pasta bin como o diretório no qual trabalhar.

Essa tarefa se aplica a todos os arquivos na base de código. Quando o Visual Studio adiciona o nome do comando para uma tarefa arbitrária ao menu de clique com o botão direito do mouse, ele prefixa o comando com Executar, como em Executar Saídas da Lista.

Se você abrir o menu de clique com o botão direito do mouse para qualquer arquivo no Gerenciador de Soluções, o comando de tarefa Executar Saídas da Lista será exibido como o último comando na seção "Compilar" do menu. Quando você seleciona Executar Saídas da Lista, o Visual Studio lista o conteúdo da pasta bin para a base de código na janela Saída:

Usar vários arquivos task.vs.json

Você pode ter vários arquivos tasks.vs.json na pasta raiz (\) e nas subpastas da base de código. Essa abordagem oferece flexibilidade para definir um comportamento diferente para subpastas ou arquivos específicos na base de código.

O Visual Studio agrega ou substitui as configurações em toda a base de código e prioriza arquivos na seguinte ordem:

1. Arquivos de configurações na pasta .vs na pasta raiz (\).
2. A pasta em que uma configuração é calculada.
3. A pasta pai da pasta atual, até e incluindo a pasta raiz (\).
4. Arquivos de configurações na pasta raiz (\).

Essas regras de agregação se aplicam somente a instâncias do arquivo tasks.vs.json.

Examinar propriedades para tasks.vs.json

As seções a seguir descrevem algumas das propriedades que você pode especificar em um arquivo tasks.vs.json.

Definir a propriedade appliesTo

Você pode criar tarefas para qualquer arquivo ou pasta especificando o nome do arquivo ou da pasta com a propriedade appliesTo, como "appliesTo": "hello.js".

A tabela a seguir resume os valores de máscara de arquivo que você pode usar com a propriedade appliesTo para gerar comportamento de tarefa específico:

Valor (máscara de arquivo)	A tarefa aplica-se a
"*"	Todos os arquivos e pastas no workspace
"*/"	Todas as pastas no workspace
"*.js"	Todos os arquivos com a extensão JavaScript (.js) no workspace
"/*.js"	Todos os arquivos com a extensão JavaScript (.js) na pasta raiz (\) do workspace
"src/*/"	Todas as subpastas da pasta src
"makefile"	Todos os arquivos chamados makefile no workspace
"/makefile"	Somente o arquivo chamado makefile na pasta raiz (\) do workspace

Usar macros em argumentos de tarefa

Você pode passar macros como argumentos de uma tarefa para aumentar o comportamento da tarefa quando o Visual Studio invoca o comando.

A tabela a seguir lista alguns exemplos de macro:

Macro	Descrição	Exemplos
${env.<VARIABLE>}	Especifica qualquer variável de ambiente utilizável no prompt de comando do desenvolvedor. Para mais informações, confira o Prompt de Comando do Desenvolvedor e o PowerShell do Desenvolvedor.	${env.PATH}, ${env.COMSPEC}
${workspaceRoot}	Fornece o caminho completo para a pasta de workspace.	C:\sources\hello, C:\sources\hello\bin
${file}	Fornece o caminho completo para o arquivo ou a pasta.	C:\sources\hello\src\hello.js*, C:\sources\hello\src\test.js*
${relativeFile}	Fornece o caminho relativo para o arquivo ou a pasta.	src\hello.js*, bin\hello.exe
${fileBasename}	Fornece o nome do arquivo, excluindo o caminho ou a extensão.	hello, test
${fileDirname}	Fornece o caminho completo para o arquivo, excluindo o nome do arquivo.	C:\sources\hello\src*, C:\sources\hello\bin\test\*
${fileExtname}	Fornece a extensão do arquivo selecionado.	.js, .cs, .exe

Configurar a depuração com launch.vs.json

O Visual Studio fornece um arquivo launch.vs.json que você pode usar para configurar a depuração para a base de código.

Observação

Para configurar projetos do CMake para depuração, confira Configurar sessões de depuração do CMake.

1. No Gerenciador de Soluções, clique com o botão direito do mouse em um arquivo executável (.exe) e selecione Adicionar Configuração de Depuração:

   

2. Na caixa de diálogo Selecionar um Depurador, selecione uma opção de configuração de depuração na lista e escolha Selecionar:

   

   Se o arquivo launch.vs.json ainda não existir, o Visual Studio o criará. Aqui está um exemplo do arquivo criado para o executável hello.exe:

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

3. Depois de ter um arquivo launch, clique com o botão direito do mouse no arquivo executável da base de código no Gerenciador de Soluções e selecione Definir como Item de Inicialização.

   O executável é definido como o item de inicialização para a sua base de código, e o Visual Studio define o rótulo para o botão Iniciar da depuração para refletir o nome do executável:

   

   Quando você inicia o depurador com F5, o Visual Studio inicia a depuração do código e para em qualquer ponto de interrupção definido. Todas as janelas conhecidas do depurador ficam disponíveis e funcionais.

   Para obter mais informações sobre tarefas personalizadas de compilação e depuração em projetos de pasta aberta do C++, confira Suporte à pasta aberta para sistemas de compilação C++ no Visual Studio.

Especificar argumentos para depuração

Você pode especificar argumentos de linha de comando para passar para o depurador no arquivo launch.vs.json. Adicione os argumentos à matriz args, conforme mostra o exemplo a seguir:

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

Iniciar uma configuração de depuração

Você pode criar quantas configurações de depuração quiser. Quando você salva o arquivo launch, os nomes de configuração são adicionados à lista suspensa de destino de depuração. Você pode selecionar um destino específico para iniciar o depurador:

Se você não vir os destinos extras no menu, selecione Mostrar/Ocultar Destinos de Depuração e configure os destinos visíveis.

Entender precedência para configurações

O Visual Studio verifica dois locais para os itens especificados na propriedade de matriz configurations nos arquivos launch.vs.json:

• A pasta raiz (\) da base de código
• A pasta .vs

Se você tiver arquivos launch.vs.json nos dois locais e houver um conflito na definição de uma configuração, o valor no arquivo .vs\launch.vs.json terá precedência.

Usar outros arquivos settings

Além dos arquivos JSON task e launch, o Visual Studio lê as configurações de outros arquivos de configuração definidos na base de código. Dois arquivos comumente usados são settings.json e .gitignore.

Definir configurações de código com .vscode\settings.json

O Visual Studio lê configurações limitadas de um arquivo chamado settings.json, quando o arquivo está localizado em uma pasta chamada .vscode.

Essa funcionalidade é fornecida para bases de código desenvolvidas anteriormente no Visual Studio Code. Atualmente, a única configuração que o arquivo .vscode\settings.json lê é files.exclude. Essa configuração é usada para filtrar arquivos visualmente no Gerenciador de Soluções e em algumas ferramentas de pesquisa.

Você pode ter vários arquivos .vscode\settings.json em sua base de código. As configurações lidas neste arquivo são aplicadas à pasta pai de .vscode e em todas as subpastas.

Configurar arquivos Git com .gitignore

Você pode usar um arquivo .gitignore para permitir que o Git saiba quais arquivos ignorar ao aplicar o controle do código-fonte. Os arquivos .gitignore são geralmente incluídos como parte de uma base de código, para que as configurações possam ser compartilhadas com todos os desenvolvedores da base de código. O Visual Studio lê padrões em arquivos .gitignore para filtrar itens visualmente e de algumas ferramentas de pesquisa.

As configurações lidas no arquivo .gitignore são aplicadas a sua pasta pai e a todas as subpastas.

Conteúdo relacionado

• Desenvolver o código sem projetos nem soluções
• Projetos Open Folder para C++
• Explorar recursos do editor de códigos