Cree tareas de compilación y depuración para el desarrollo de "Abrir carpeta"

Visual Studio puede ejecutar automáticamente muchos lenguajes de programación y código base diferentes. La opción Abrir carpeta le permite ejecutar código inmediatamente para un código base reconocido sin instrucciones especiales y sin crear un proyecto. Los desarrolladores suelen usar este enfoque para realizar pruebas rápidas.

Algunos código base requieren herramientas de compilación personalizadas que Visual Studio no reconoce o no puede procesar inmediatamente con la opción Abrir carpeta. En estos escenarios, puede definir tareas de compilación para indicar a Visual Studio cómo compilar y depurar el código. Las tareas de compilación especifican todos los elementos que un lenguaje necesita para compilar y ejecutar el código, y se pueden usar para completar casi cualquier operación necesaria.

En este artículo se describe cómo definir tareas de compilación para configurar las opciones de compilación y depuración de una base de código sin proyecto no reconocida en Visual Studio.

Exploración de archivos de configuración JSON

Para personalizar un código base sin proyecto, Visual Studio proporciona dos archivos JSON (.json) para las opciones de configuración: tareas e inicio. Visual Studio crea (o abre) estos archivos según sea necesario, al seleccionar opciones específicas en Visual Studio Explorador de soluciones.

En la tabla siguiente se describen los archivos JSON y cómo crearlos en el Explorador de soluciones.

Archivo JSON	Propósito de configuración	Acceso a archivos
tasks.vs.json	Definir modificadores del compilador y los comandos de compilación personalizados, además de las tareas arbitrarias (no relacionadas con la compilación).	En el Explorador de soluciones, haga clic con el botón derecho en un archivo o carpeta para abrir el menú contextual y seleccione Configurar tareas.
launch.vs.json	Especifique los argumentos de la línea de comandos para realizar la depuración.	En el Explorador de soluciones, haga clic con el botón derecho en un archivo o carpeta para abrir el menú contextual y seleccione Agregar configuración de depuración.

Agregar archivos JSON al control de código fuente

De forma predeterminada, los archivos JSON de tareas e iniciar no están visibles en el Explorador de soluciones. Los archivos se encuentran en una carpeta oculta llamada .vs en la carpeta raíz (\) del código base. Los archivos están ocultos porque normalmente no se agregan al control de código fuente. Para ver archivos ocultos en Visual Studio, seleccione la opción Mostrar todos los archivos en el Explorador de soluciones.

Si desea agregar los archivos JSON al control de código fuente, arrastre los archivos a la carpeta raíz (\) del código base en el sistema de archivos. Los archivos se vuelven visibles en el Explorador de soluciones y están disponibles para el control de código fuente.

Definición de tareas con tasks.vs.json

Puede automatizar los scripts de compilación y operaciones externas en los archivos del área de trabajo actual ejecutando las acciones como tareas directamente en Visual Studio. Para configurar una nueva tarea, haga clic con el botón derecho en un archivo o carpeta en el Explorador de soluciones y seleccione Configurar tareas:

Esta acción crea (o abre) el archivo tasks.vs.json en la carpeta .vs. Define una tarea de compilación o una tarea arbitraria en este archivo y Visual Studio agrega el nombre de la tarea como un comando al menú contextual del Explorador de soluciones. Para invocar la tarea, seleccione el comando correspondiente en el Explorador de soluciones.

Se pueden agregar tareas personalizadas a archivos individuales o a todos los archivos de un tipo específico. Por ejemplo, los archivos de paquete de NuGet pueden configurarse para que tengan una tarea "Restaurar paquetes" o todos los archivos de origen pueden configurarse para que tengan una tarea de análisis estático, como un linter para todos los archivos JavaScript (.js).

Creación de tareas para herramientas no reconocidas

Si el código base usa las herramientas de compilación personalizadas que Visual Studio no reconoce, no podrá ejecutar ni depurar el código en Visual Studio hasta que complete pasos de configuración adicionales.

Puede definir tareas de compilación para indicar a Visual Studio cómo compilar, recompilar y limpiar el código. El archivo tasks.vs.json combina el bucle de desarrollo interno de Visual Studio con las herramientas de compilación personalizadas definidas para el código base.

Supongamos que el código base tiene un único archivo de C# denominado hello.cs. El archivo Make para este tipo de código base podría parecerse a este ejemplo:

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 un archivo Make similar que contiene destinos de compilación, limpieza y recompilación, puede usar la opción Configurar tareas para el archivo Make y definir el siguiente archivo tasks.vs.json. El archivo JSON define las tareas para compilar, recompilar y limpiar el código base mediante NMAKE como herramienta de compilación:

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

Después de definir tareas de compilación en el archivo tasks.vs.json, Visual Studio agrega los comandos de tarea correspondientes al menú contextual del Explorador de soluciones. En este ejemplo, las opciones Compilar, Recompilar y Limpiar se agregan al menú contextual para las instancias del archivo Make en el código base:

Visual Studio muestra los nuevos comandos en el menú contextual después del comando Configurar tareas según su configuración de contextType. "build", "rebuild" y "clean" son comandos de compilación y se enumeran en la sección "Compilar" del menú contextual.

Al seleccionar un comando de tarea personalizada en el menú contextual, se ejecuta la operación. Visual Studio muestra la salida del comando en la ventana Salida y los errores de compilación en la Lista de errores.

Creación de tareas para operaciones arbitrarias

Puede definir tareas personalizadas en el archivo tasks.vs.json para cualquier operación arbitraria. Puede definir una tarea para mostrar el nombre del archivo seleccionado actualmente en la ventana Salida o para enumerar los archivos de una carpeta específica.

Ejemplo: Nombre para mostrar del archivo seleccionado actualmente

En el ejemplo siguiente se muestra un archivo tasks.vs.json que define una sola tarea arbitraria. Al invocar esta tarea, la operación muestra el nombre del archivo JavaScript (.js) seleccionado actualmente.

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

El código de esta tarea define las siguientes propiedades:

• taskName: nombre del comando de tarea para que Visual Studio lo muestre en el menú contextual. En este caso, Nombre de archivo Echo.
• appliesTo: los archivos sobre los que actuará el comando de tarea. En este caso, los archivos de JavaScript (.js).
• command: el comando que se debe invocar. Esta tarea usa la variable de entorno COMSPEC para identificar el intérprete de la línea de comandos (normalmente cmd.exe).
• args: argumentos que se van a pasar cuando Visual Studio invoque el comando.
• ${file}: los argumentos de esta tarea incluyen una macro que recupera el archivo seleccionado actualmente en el Explorador de soluciones.

Después de guardar el archivo tasks.vs.json, puede hacer clic con el botón derecho en cualquier archivo JavaScript (.js) de la carpeta y seleccionar Nombre de archivo Echo. Visual Studio muestra el nombre del archivo seleccionado en la ventana Salida.

Ejemplo: Enumerar archivos y subcarpetas

En el ejemplo siguiente se muestra un archivo tasks.vs.json que define una tarea para enumerar los archivos y subcarpetas de la carpeta bin:

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

El código de esta tarea define las siguientes propiedades:

• taskName: nombre del comando de tarea del menú contextual, Enumerar salidas.
• appliesTo: esta tarea actúa en todos los elementos de la carpeta especificada, como se indica con el uso del carácter comodín (*).
• command: similar al ejemplo anterior, la tarea usa la variable de entorno COMSPEC para identificar el intérprete de línea de comandos (cmd.exe).
• args: cuando Visual Studio invoca la tarea, pasa una llamada al comando dir, que enumera los elementos del directorio (carpeta).
• ${outDir}: la macro {outDir} se define antes del bloque tasks. Identifica la carpeta bin como directorio en el que actuar.

Esta tarea se aplica a todos los archivos del código base. Cuando Visual Studio agrega el nombre del comando para una tarea arbitraria al menú contextual, le agrega el prefijo Ejecutar, como en Ejecutar enumeración de salidas.

Si abre el menú contextual de cualquier archivo en el Explorador de soluciones, el comando de tarea Ejecutar enumeración de salidas aparece como el último comando de la sección "Compilar" del menú. Al seleccionar Ejecutar enumeración de salidas, Visual Studio enumera el contenido de la carpeta bin para el código base en la ventana Salida:

Uso de varios archivos task.vs.json

Puede tener varios archivos tasks.vs.json en la carpeta raíz (\) y las subcarpetas de su base de código. Este enfoque proporciona flexibilidad para definir un comportamiento diferente para subcarpetas o archivos específicos en el código base.

Visual Studio agrega o invalida la configuración en todo el código base y establece la prioridad de los archivos en el siguiente orden:

1. Archivos de configuración de la carpeta .vs de la carpeta raíz (\).
2. Carpeta donde se calcula una configuración.
3. La carpeta primaria de la carpeta actual, hasta la carpeta raíz (\) incluida.
4. Los archivos de configuración de la carpeta raíz (\).

Estas reglas de agregación solo se aplican a las instancias del archivo tasks.vs.json.

Análisis de las propiedades de tasks.vs.json

En las secciones siguientes se describen algunas de las propiedades que se pueden especificar en un archivo tasks.vs.json.

Establecimiento de la propiedad appliesTo

Puede crear tareas para cualquier archivo o carpeta especificando el nombre de archivo o carpeta con la propiedad appliesTo, como "appliesTo": "hello.js".

En la tabla siguiente se resumen los valores de máscara de archivo que puede usar con la propiedad appliesTo para generar un comportamiento de tarea específico:

Valor (máscara de archivo)	Tarea aplicable a
"*"	Todos los archivos y carpetas del área de trabajo
"*/"	Todas las carpetas del área de trabajo
"*.js"	Todos los archivos con la extensión JavaScript (.js) del área de trabajo
"/*.js"	Todos los archivos con la extensión JavaScript (.js) de la carpeta raíz (\) del área de trabajo
"src/*/"	Todas las subcarpetas de la carpeta src
"makefile"	Todos los archivos denominados makefile en el área de trabajo
"/makefile"	Solo el archivo denominado makefile en la carpeta raíz (\) del área de trabajo

Uso de macros en argumentos de tarea

Puede pasar macros como argumentos para una tarea para aumentar el comportamiento de la tarea cuando Visual Studio invoca el comando.

Se muestran algunos ejemplos de macro en la tabla siguiente:

Macro	Descripción	Ejemplos
${env.<VARIABLE>}	Especifica cualquier variable de entorno que se pueda usar en el símbolo del sistema para desarrolladores. Para más información, consulte Símbolo del sistema para desarrolladores y PowerShell para desarrolladores.	${env.PATH}, ${env.COMSPEC}
${workspaceRoot}	Proporciona la ruta de acceso completa a la carpeta del área de trabajo.	C:\sources\hello, C:\sources\hello\bin
${file}	Proporciona la ruta de acceso completa al archivo o carpeta.	C:\sources\hello\src\hello.js*, C:\sources\hello\src\test.js*
${relativeFile}	Proporciona la ruta de acceso relativa al archivo o carpeta.	src\hello.js*, bin\hello.exe
${fileBasename}	Proporciona el nombre del archivo, excepto la ruta de acceso o la extensión.	hello, test
${fileDirname}	Proporciona la ruta de acceso completa al archivo, excepto el nombre de archivo.	C:\sources\hello\src*, C:\sources\hello\bin\test\*
${fileExtname}	Proporciona la extensión del archivo seleccionado.	.js, .cs, .exe

Configuración de la depuración con launch.vs.json

Visual Studio proporciona un archivo launch.vs.json que puede usar para configurar la depuración para el código base.

Nota:

Para configurar proyectos de CMake para la depuración, vea Configuración de sesiones de depuración de CMake.

1. En el Explorador de soluciones, haga clic con el botón derecho en un archivo (.exe) ejecutable y seleccione Agregar configuración de depuración:

   

2. En el cuadro de diálogo Seleccionar un depurador, seleccione una opción de configuración de depuración de la lista y, a continuación, elija Seleccionar:

   

   Si el archivo launch.vs.json aún no existe, Visual Studio lo crea. Este es un ejemplo del archivo creado para el archivo ejecutable de hello.exe:

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

3. Después de tener un archivo de inicio, haga clic con el botón derecho en el archivo ejecutable del código base en el Explorador de soluciones y seleccione Establecer como elemento de inicio.

   El archivo ejecutable se designa como el elemento de inicio del código base y Visual Studio establece la etiqueta para el botón Iniciar depuración para reflejar el nombre del archivo ejecutable:

   

   Al iniciar el depurador con F5, Visual Studio inicia la depuración del código y se detiene en cualquier punto de interrupción establecido. Todas las ventanas familiares del depurador están disponibles y en funcionamiento.

   Para obtener más información sobre las tareas de compilación y depuración personalizadas en proyectos de abrir carpeta de C++, consulte Compatibilidad de la acción Abrir carpeta con sistemas de compilación de C++ en Visual Studio.

Especificación de argumentos para la depuración

Puede especificar los argumentos de la línea de comandos que se van a pasar al depurador en el archivo launch.vs.json. Agregue los argumentos de la matriz args, tal como se muestra en el ejemplo siguiente:

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

Inicio de una configuración de depuración

Puede crear tantas configuraciones de depuración como desee. Al guardar el archivo de inicio , los nombres de configuración se agregan a la lista desplegable de destino de depuración. Puede seleccionar un destino específico para iniciar el depurador:

Si no ve los destinos adicionales en el menú, seleccione Mostrar u ocultar destinos de depuración y configure los destinos visibles.

Descripción de la prioridad de las configuraciones

Visual Studio examina dos ubicaciones para los elementos especificados en la propiedad de matriz configurations en archivos launch.vs.json:

• La carpeta raíz (\) para el código base
• La carpeta .vs

Si tiene archivos launch.vs.json en ambas ubicaciones y hay un conflicto en la definición de una configuración, el valor del archivo .vs\launch.vs.json tiene prioridad.

Uso de otros archivos de configuración

Además de los archivos JSON de tarea e iniciar, Visual Studio lee la configuración de otros archivos de configuración definidos en el código base. Dos archivos usados habitualmente incluyen settings.json y .gitignore.

Definición de la configuración de código con .vscode\settings.json

Visual Studio lee la configuración limitada de un archivo denominado settings.json, cuando el archivo se encuentra en una carpeta denominada .vscode.

Esta funcionalidad se proporciona para los códigos base que se desarrollaron anteriormente en Visual Studio Code. Actualmente, la única configuración de lectura del archivo .vscode\settings.json es files.exclude. Esta configuración se usa para filtrar archivos visualmente en el Explorador de soluciones y desde algunas herramientas de búsqueda.

Puede tener varios archivos .vscode\settings.json en el código base. La configuración que se lee de este archivo se aplica a la carpeta principal de .vscode y a todas las subcarpetas.

Configuración de archivos Git con .gitignore

Puede usar un archivo .gitignore para que Git sepa qué archivos debe omitir al aplicar el control de código fuente. Los archivos .gitignore se incluyen habitualmente como parte de un código base para que la configuración se pueda compartir con todos los desarrolladores del código base. Visual Studio lee patrones en los archivos .gitignore para filtrar los archivos de manera visual y desde algunas herramientas de búsqueda.

La configuración que se lee del archivo .gitignore se aplica a la carpeta principal y a todas las subcarpetas.

Contenido relacionado

• Desarrollo de código en Visual Studio sin proyectos o soluciones
• Open Folder projects for C++ (Proyectos Abrir carpeta para C++)
• Exploración de las características del editor de código