Erstellen von Build- und Debugtasks für die „Ordner öffnen“-Entwicklung

Visual Studio kann automatisch viele verschiedene Programmiersprachen und Codebasen ausführen. Mit der Option „Ordner öffnen“ können Sie sofort Code für eine erkannte Codebasis ausführen, ohne dass spezielle Anweisungen erforderlich sind oder ein Projekt erstellt werden muss. Entwickler*innen verwenden diesen Ansatz häufig, um schnell Tests auszuführen.

Einige Codebasen erfordern benutzerdefinierte Buildtools, die von Visual Studio nicht erkannt werden oder nicht sofort mit der Option „Ordner öffnen“ verarbeitet werden können. Für diese Szenarien können Sie Buildtasks definieren, um Visual Studio anzuweisen, wie der Code erstellt und gedebuggt werden soll. In den Buildtasks sind alle Elemente angegeben, die eine Programmiersprache zum Erstellen und Ausführen des Codes benötigt. Die Tasks können zur Ausführung praktisch jedes erforderlichen Vorgangs verwendet werden.

In diesem Artikel wird beschrieben, wie Sie in Visual Studio Buildtasks zum Konfigurieren von Build- und Debugeinstellungen für eine nicht erkannte, projektlose Codebasis definieren.

Übersicht über JSON-Konfigurationsdateien

Zum Anpassen einer projektlosen Codebasis bietet Visual Studio zwei JSON-Dateien (.json) für Konfigurationseinstellungen: tasks und launch. Visual Studio erstellt (oder öffnet) diese Dateien nach Bedarf, wenn Sie bestimmte Optionen im Projektmappen-Explorer von Visual Studio auswählen.

In der folgenden Tabelle werden die JSON-Dateien und ihre Erstellung im Projektmappen-Explorer beschrieben.

Hinzufügen von JSON-Dateien zur Quellcodeverwaltung

Die JSON-Dateien tasks und launch sind im Projektmappen-Explorer standardmäßig nicht sichtbar. Die Dateien befinden sich in einem ausgeblendeten Ordner namens .vs im Stammordner (\) Ihrer Codebasis. Die Dateien sind ausgeblendet, da sie normalerweise nicht zur Quellcodeverwaltung hinzugefügt werden. Sie können ausgeblendete Dateien in Visual Studio anzeigen, indem Sie im Projektmappen-Explorer die Option Alle Dateien anzeigen auswählen.

Wenn Sie die JSON-Dateien zur Quellcodeverwaltung hinzufügen möchten, ziehen Sie die Dateien in den Stammordner (\) Ihrer Codebasis in Ihrem Dateisystem. Die Dateien werden im Projektmappen-Explorer sichtbar und sind für die Quellcodeverwaltung verfügbar.

Definieren von Tasks mit „tasks.vs.json“

Sie können Buildskripts und externe Vorgänge für Dateien in Ihrem aktuellen Arbeitsbereich automatisieren, indem Sie die Aktionen direkt in Visual Studio als Tasks ausführen. Um einen neuen Task zu konfigurieren, klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf eine Datei oder einen Ordner, und wählen Sie Tasks konfigurieren aus:

Durch diese Aktion wird die tasks.vs.json-Datei im Ordner .vs erstellt (oder geöffnet). Wenn Sie einen Buildtask oder einen beliebigen Task in dieser Datei definieren, wird der Name des Tasks in Visual Studio dem Kontextmenü des Projektmappen-Explorers als Befehl hinzugefügt. Sie können den Task aufrufen, indem Sie den entsprechenden Befehl im Projektmappen-Explorer auswählen.

Benutzerdefinierte Tasks können zu einzelnen Dateien oder zu allen Dateien eines bestimmten Typs hinzugefügt werden. Sie können z. B. NuGet-Paketdateien mit einem Task „Pakete wiederherstellen“ konfigurieren. Alternativ können Sie alle Quelldateien so konfigurieren, dass sie einen statischen Analysetask aufweisen, z. B. einen Linter für alle JavaScript-Dateien (.js).

Erstellen von Tasks für nicht erkannte Tools

Wenn Ihre Codebasis benutzerdefinierte Buildtools nutzt, die von Visual Studio nicht erkannt werden, können Sie den Code in Visual Studio erst ausführen und debuggen, nachdem Sie zusätzliche Konfigurationsschritte ausgeführt haben.

Sie können Buildtasks definieren, um Visual Studio anzuweisen, wie Code erstellt, neu erstellt und bereinigt werden soll. In der tasks.vs.json-Datei wird die innere Entwicklungsschleife von Visual Studio mit den benutzerdefinierten Buildtools kombiniert, die Sie für Ihre Codebasis definieren.

Angenommen, Ihre Codebasis verfügt über eine einzelne C#-Datei mit dem Namen hello.cs. Das Makefile für eine solche Codebasis könnte wie im folgenden Beispiel aussehen:

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

Um ein ähnliches Makefile mit Zielen für die Erstellung, Bereinigung und Neuerstellung zu erhalten, können Sie für das Makefile die Option Tasks konfigurieren verwenden und die folgende tasks.vs.json-Datei definieren. In der JSON-Datei sind Tasks zum Erstellen, Neuerstellen und Bereinigen der Codebasis definiert. Dabei wird NMAKE als Buildtool verwendet:

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

Nachdem Sie Buildtasks in der tasks.vs.json-Datei definiert haben, fügt Visual Studio dem Kontextmenü im Projektmappen-Explorer die entsprechenden Taskbefehle hinzu. In diesem Beispiel werden dem Kontextmenü für Instanzen von Makefile in der Codebasis die Optionen Erstellen, Neu erstellen und Bereinigen hinzugefügt:

Visual Studio listet die neuen Befehle im Kontextmenü nach dem Befehl Tasks konfigurieren entsprechend ihren contextType-Einstellungen auf. „build“, „rebuild“ und „clean“ sind Buildbefehle und werden im Abschnitt „Erstellen“ des Kontextmenüs aufgelistet.

Wenn Sie im Kontextmenü einen Befehl für einen benutzerdefinierten Task auswählen, wird der Vorgang ausgeführt. Visual Studio zeigt die Befehlsausgabe im Ausgabefenster und Buildfehler in der Fehlerliste an.

Erstellen von Tasks für beliebige Vorgänge

In der tasks.vs.json-Datei können Sie benutzerdefinierte Tasks für beliebige Vorgänge definieren. Sie können z. B. einen Task definieren, um den Namen der aktuell ausgewählten Datei im Ausgabefenster anzuzeigen oder um die Dateien in einem bestimmten Ordner aufzulisten.

Beispiel: Anzeigename der aktuell ausgewählten Datei

Das folgende Beispiel zeigt eine tasks.vs.json-Datei, in der ein einzelner beliebiger Task definiert ist. Wenn Sie diesen Task aufrufen, zeigt der Vorgang den Dateinamen der aktuell ausgewählten JavaScript-Datei (.js) an.

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

Der Code für diesen Task definiert die folgenden Eigenschaften:

• taskName: Der Befehlsname des Tasks für Visual Studio, der im Kontextmenü angezeigt werden soll. In diesem Fall Echo filename.
• appliesTo: Die Dateien, für die der Taskbefehl ausgeführt werden soll. In diesem Fall JavaScript-Dateien (.js).
• command: Der Befehl, der aufgerufen werden soll. Dieser Task verwendet die Umgebungsvariable COMSPEC, um den Befehlszeileninterpreter zu identifizieren (in der Regel cmd.exe).
• args: Alle Argumente, die übergeben werden sollen, wenn Visual Studio den Befehl aufruft.
• ${file}: Die Argumente für diesen Task enthalten ein Makro, das die aktuell im Projektmappen-Explorer ausgewählte Datei abruft.

Nachdem Sie die tasks.vs.json-Datei gespeichert haben, können Sie mit der rechten Maustaste auf eine beliebige JavaScript-Datei (.js) im Ordner klicken und Echo filename auswählen. Visual Studio zeigt den ausgewählten Dateinamen im Ausgabefenster an.

Beispiel: Auflisten von Dateien und Unterordnern

Das folgende Beispiel zeigt eine tasks.vs.json-Datei, die einen Task definiert, um die Dateien und Unterordner des Ordners bin aufzulisten:

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

Der Code für diesen Task definiert die folgenden Eigenschaften:

• taskName: Der Befehlsname des Tasks für das Kontextmenü, List Outputs.
• appliesTo: Dieser Task wird für alle Elemente im angegebenen Ordner ausgeführt, wie an der Verwendung des Platzhalters (*) erkennbar.
• command: Ähnlich wie im vorherigen Beispiel verwendet der Task die Umgebungsvariable COMSPEC, um den Befehlszeileninterpreter (cmd.exe) zu identifizieren.
• args: Wenn Visual Studio den Task aufruft, wird ein Aufruf an den dir-Befehl übergeben, der die Verzeichniselemente (Ordnerelemente) auflistet.
• ${outDir}: Das {outDir}-Makro wird vor dem tasks-Block definiert. Es identifiziert den Ordner bin als das Verzeichnis, für das der Vorgang ausgeführt wird.

Dieser Task wird auf alle Dateien in der Codebasis angewendet. Wenn Visual Studio dem Kontextmenü den Befehlsnamen für einen beliebigen Task hinzufügt, wird dem Befehl Ausführen vorangestellt, wie in Ausführen: List Outputs zu sehen.

Wenn Sie das Kontextmenü für eine Datei im Projektmappen-Explorer öffnen, wird der Taskbefehl Ausführen: List Outputs im Abschnitt „Erstellen“ des Menüs als letzter Befehl angezeigt. Wenn Sie Ausführen: List Outputs auswählen, listet Visual Studio den Inhalt des Ordners bin für die Codebasis im Ausgabefenster auf:

Verwenden mehrerer task.vs.json-Dateien

Der Stammordner (\) und die Unterordner Ihrer Codebasis können mehrere tasks.vs.json-Dateien enthalten. Mit diesem Ansatz können Sie flexibel unterschiedliche Verhaltensweisen für bestimmte Unterordner oder Dateien Ihrer Codebasis definieren.

Visual Studio aggregiert oder überschreibt Einstellungen in der gesamten Codebasis und priorisiert Dateien in der folgenden Reihenfolge:

1. Einstellungsdateien im Ordner .vs im Stammordner (\)
2. Der Ordner, in dem eine Einstellung berechnet wird
3. Der übergeordnete Ordner des aktuellen Ordners bis einschließlich des Stammordners (\)
4. Einstellungsdateien im Stammordner (\)

Diese Aggregationsregeln gelten nur für Instanzen der tasks.vs.json-Datei.

Erläuterung der Eigenschaften für „tasks.vs.json“

In den folgenden Abschnitten werden einige Eigenschaften beschrieben, die Sie in einer tasks.vs.json-Datei angeben können.

Festlegen der „appliesTo“-Eigenschaft

Sie können Tasks für beliebige Dateien oder Ordner erstellen, indem Sie den Datei- oder Ordnernamen mit der appliesTo-Eigenschaft angeben, z. B. "appliesTo": "hello.js".

In der folgenden Tabelle sind die Dateimaskenwerte zusammengefasst, die Sie mit der appliesTo-Eigenschaft verwenden können, um ein bestimmtes Taskverhalten zu erzeugen:

Verwenden von Makros in Taskargumenten

Sie können Makros als Argumente für einen Task übergeben, um das Taskverhalten zu erweitern, wenn der Befehl von Visual Studio aufgerufen wird.

In der folgenden Tabelle sind einige Beispiele für Makros aufgeführt:

Konfigurieren des Debuggens mit „launch.vs.json“

Visual Studio bietet eine launch.vs.json-Datei, die Sie verwenden können, um das Debuggen für Ihre Codebasis zu konfigurieren.

1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf eine ausführbare Datei (.exe), und wählen Sie Debugkonfiguration hinzufügen aus:

   

2. Wählen Sie im Dialogfeld Debugger auswählen eine Debugkonfigurationsoption aus der Liste aus, und wählen Sie dann Auswählen aus:

   

   Wenn die launch.vs.json-Datei noch nicht vorhanden ist, wird sie von Visual Studio erstellt. Hier ein Beispiel für die Datei, die für die ausführbare Datei hello.exe erstellt wurde:

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

3. Sobald Sie über eine launch-Datei verfügen, klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf die ausführbare Datei für Ihre Codebasis und wählen Als Startelement festlegen aus.

   Die ausführbare Datei wird als Startelement für Ihre Codebasis festgelegt, und die Beschriftung der Schaltfläche Start für Debugvorgänge wird von Visual Studio entsprechend dem Namen Ihrer ausführbaren Datei festgelegt:

   

   Wenn Sie den Debugger mit F5 starten, beginnt Visual Studio mit dem Debuggen Ihres Codes und hält an jedem festgelegten Haltepunkt an. Alle vertrauten Debuggerfenster sind verfügbar und funktionsfähig.

   Weitere Informationen zu benutzerdefinierten Build- und Debugtasks in „Ordner öffnen“-Projekten für C++ finden Sie unter „Ordner öffnen“-Unterstützung für C++-Buildsysteme in Visual Studio.

Angeben von Argumenten für das Debuggen

Sie können in der launch.vs.json-Datei Befehlszeilenargumente angeben, die an den Debugger übergeben werden. Fügen Sie die Argumente im args-Array hinzu, wie im folgenden Beispiel gezeigt:

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

Starten einer Debugkonfiguration

Sie können so viele Debugkonfigurationen erstellen, wie Sie möchten. Wenn Sie die launch-Datei speichern, werden die Konfigurationsnamen der Dropdownliste für das Debugziel hinzugefügt. Sie können ein bestimmtes Ziel auswählen, um den Debugger zu starten:

Wenn die zusätzlichen Ziele im Menü nicht angezeigt werden, wählen Sie Debugziele ein-/ausblenden und konfigurieren die sichtbaren Ziele.

Grundlegendes zur Rangfolge von Konfigurationen

Visual Studio sucht an zwei Speicherorten nach den in der configurations-Arrayeigenschaft in launch.vs.json-Dateien angegebenen Elementen:

• Im Stammordner (\) der Codebasis
• Im Ordner .vs

Wenn an beiden Speicherorten launch.vs.json-Dateien enthalten sind und in der Definition einer Konfiguration ein Konflikt vorliegt, hat der Wert in der .vs\launch.vs.json-Datei Vorrang.

Verwenden anderer Einstellungsdateien

Neben den JSON-Dateien task und launch liest Visual Studio Einstellungen aus anderen Konfigurationsdateien, die in Ihrer Codebasis definiert sind. Zwei häufig verwendete Dateien sind settings.json und .gitignore.

Definieren von Codeeinstellungen mit „.vscode\settings.json“

Visual Studio liest begrenzte Einstellungen aus einer Datei namens settings.json, wenn sich die Datei in einem Ordner mit dem Namen .vscode befindet.

Diese Funktionalität wird für Codebasen bereitgestellt, die zuvor in Visual Studio Code entwickelt wurden. Derzeit lautet die einzige Einstellung, die aus der Datei unter .vscode\settings.json gelesen wird files.exclude. Diese Einstellung wird verwendet, um Dateien visuell im Projektmappen-Explorer und in einigen Suchtools zu filtern.

Ihre Codebasis kann mehrere .vscode\settings.json-Dateien enthalten. Aus dieser Datei gelesene Einstellungen werden auf den übergeordneten Ordner von .vscode und alle Unterordner angewendet.

Konfigurieren von Git-Dateien mit „.gitignore“

Sie können eine .gitignore-Datei verwenden, um Git mitzuteilen, welche Dateien von der Quellcodeverwaltung ignoriert werden sollen. .gitignore-Dateien werden üblicherweise in die Codebasis aufgenommen, damit die Einstellungen für alle Entwickler der Codebasis freigegeben werden können. Visual Studio liest Muster in .gitignore-Dateien, um Elemente visuell und aus einigen Suchtools zu filtern.

Aus der .gitignore-Datei gelesene Einstellungen werden auf den übergeordneten Ordner und alle Unterordner angewendet.

Zugehöriger Inhalt

• Entwickeln von Code in Visual Studio ohne Projekte oder Projektmappen
• Open Folder-Projekte für C++
• Erkunden von Code-Editor-Funktionen