Udostępnij za pośrednictwem

Dostosowywanie zadań kompilacji i debugowania na potrzeby programowania "Otwórz folder"

  • Artykuł

Program Visual Studio wie, jak uruchamiać wiele różnych języków i baz kodu, ale nie wie, jak uruchomić wszystko. Jeśli otwarto folder kodu w programie Visual Studio, a program Visual Studio wie, jak uruchomić kod, możesz go uruchomić od razu bez konieczności dodatkowej konfiguracji.

Jeśli baza kodu używa niestandardowych narzędzi kompilacji, których program Visual Studio nie rozpoznaje, musisz podać pewne szczegóły konfiguracji, aby uruchomić i debugować kod w programie Visual Studio. Należy poinstruować program Visual Studio, jak skompilować kod, definiując zadania kompilacji. Możesz utworzyć co najmniej jedno zadanie kompilacji, aby określić wszystkie elementy, których język musi skompilować i uruchomić jego kod. Możesz również utworzyć dowolne zadania, które mogą wykonywać niemal dowolne zadania. Możesz na przykład utworzyć zadanie, aby wyświetlić listę zawartości folderu lub zmienić nazwę pliku.

Dostosuj bazę kodu bez projektu przy użyciu następujących plików json :

Nazwa pliku Purpose
tasks.vs.json Określ niestandardowe polecenia kompilacji i przełączniki kompilatora oraz dowolne zadania (niezwiązane z kompilacją).
Dostęp za pośrednictwem Eksplorator rozwiązań kliknij prawym przyciskiem myszy element menu Konfiguruj zadania.
launch.vs.json Określ argumenty wiersza polecenia na potrzeby debugowania.
Dostęp za pośrednictwem Eksplorator rozwiązań kliknij prawym przyciskiem myszy element menu Debug and Launch Ustawienia (Debuguj i uruchom Ustawienia).

Te pliki json znajdują się w ukrytym folderze o nazwie .vs w folderze głównym bazy kodu. Pliki tasks.vs.json i launch.vs.json są tworzone przez program Visual Studio zgodnie z potrzebami podczas wybierania opcji Konfiguruj zadania lub Debuguj i Uruchom Ustawienia w pliku lub folderze w Eksplorator rozwiązań. Te pliki json są ukryte, ponieważ użytkownicy zazwyczaj nie chcą ich zaewidencjonować w kontroli źródła. Jeśli jednak chcesz mieć możliwość zaewidencjonowania ich w kontroli źródła, przeciągnij pliki do katalogu głównego bazy kodu przy użyciu systemu plików, gdzie są one widoczne w Eksplorator rozwiązań i kontroli źródła.

Napiwek

Aby wyświetlić ukryte pliki w programie Visual Studio, wybierz przycisk Pokaż wszystkie pliki na pasku narzędzi Eksplorator rozwiązań.

Definiowanie zadań za pomocą pliku tasks.vs.json

Skrypty kompilacji lub inne operacje zewnętrzne można zautomatyzować na plikach w bieżącym obszarze roboczym, uruchamiając je jako zadania bezpośrednio w środowisku IDE. Nowe zadanie można skonfigurować, klikając prawym przyciskiem myszy plik lub folder i wybierając polecenie Konfiguruj zadania.

Configure Tasks menu

Spowoduje to utworzenie (lub otwarcie) pliku tasks.vs.json w folderze .vs . Możesz zdefiniować zadanie kompilacji lub dowolne zadanie w tym pliku, a następnie wywołać je przy użyciu nazwy nadanej w menu Eksplorator rozwiązań prawym przyciskiem myszy.

Zadania niestandardowe można dodawać do poszczególnych plików lub do wszystkich plików określonego typu. Na przykład pliki pakietów NuGet można skonfigurować tak, aby miały zadanie "Przywróć pakiety" lub wszystkie pliki źródłowe można skonfigurować tak, aby miały zadanie analizy statycznej, takie jak linter dla wszystkich plików js .

Definiowanie niestandardowych zadań kompilacji

Jeśli baza kodu używa niestandardowych narzędzi kompilacji, których program Visual Studio nie rozpoznaje, nie można uruchomić i debugować kodu w programie Visual Studio do momentu wykonania niektórych kroków konfiguracji. Program Visual Studio udostępnia zadania kompilacji, w których można poinformować program Visual Studio, jak kompilować, kompilować, kompilować i czyścić kod. Plik zadań kompilacji tasks.vs.json łączy wewnętrzną pętlę tworzenia programu Visual Studio z niestandardowymi narzędziami kompilacji używanymi przez bazę kodu.

Rozważmy bazę kodu składającą się z pojedynczego pliku C# o nazwie hello.cs. Plik make dla takiej bazy kodu może wyglądać następująco:

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

W przypadku takiego pliku make, który zawiera obiekty docelowe kompilacji, czyszczenia i ponownego kompilowania, można zdefiniować następujący plik tasks.vs.json . Zawiera trzy zadania kompilacji służące do kompilowania, odbudowywania i czyszczenia bazy kodu przy użyciu narzędzia NMAKE.

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

Po zdefiniowaniu zadań kompilacji w pliku tasks.vs.json dodatkowe elementy menu prawym przyciskiem myszy (menu kontekstowe) są dodawane do odpowiednich plików w Eksplorator rozwiązań. W tym przykładzie opcje "build", "rebuild" i "clean" są dodawane do menu kontekstowego dowolnych plików makefile .

makefile context menu with build, rebuild, and clean

Uwaga

Polecenia są wyświetlane w menu kontekstowym w obszarze polecenia Konfiguruj zadania ze względu na ich contextType ustawienia. Polecenia "build", "rebuild" i "clean" to polecenia kompilacji, dlatego są wyświetlane w sekcji kompilacji w środku menu kontekstowego.

Po wybraniu jednej z tych opcji zadanie zostanie wykonane. Dane wyjściowe są wyświetlane w oknie Dane wyjściowe , a błędy kompilacji są wyświetlane na liście błędów.

Definiowanie dowolnych zadań

Możesz zdefiniować dowolne zadania w pliku tasks.vs.json , aby wykonać tylko dowolne czynności. Można na przykład zdefiniować zadanie, aby wyświetlić nazwę aktualnie wybranego pliku w oknie Dane wyjściowe lub wyświetlić listę plików w określonym katalogu.

W poniższym przykładzie przedstawiono plik tasks.vs.json , który definiuje jedno zadanie. Po wywołaniu zadanie wyświetla nazwę pliku aktualnie wybranego pliku js .

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskName": "Echo filename",
      "appliesTo": "*.js",
      "type": "default",
      "command": "${env.COMSPEC}",
      "args": [ "echo ${file}" ]
    }
  ]
}
  • taskName określa nazwę wyświetlaną w menu prawym przyciskiem myszy.
  • appliesTo określa, na których plikach można wykonać polecenie.
  • Właściwość command określa polecenie do wywołania. W tym przykładzie zmienna COMSPEC środowiskowa służy do identyfikowania interpretera wiersza polecenia, zazwyczaj cmd.exe.
  • Właściwość args określa argumenty, które mają być przekazywane do wywoływanego polecenia.
  • Makro ${file} pobiera wybrany plik w Eksplorator rozwiązań.

Po zapisaniu pliku tasks.vs.json możesz kliknąć prawym przyciskiem myszy dowolny plik js w folderze i wybrać nazwę pliku Echo. Nazwa pliku jest wyświetlana w oknie Dane wyjściowe .

Uwaga

Jeśli baza kodu nie zawiera pliku tasks.vs.json, możesz go utworzyć, wybierając polecenie Konfiguruj zadania w menu kontekstowym lub prawym przyciskiem myszy pliku w Eksplorator rozwiązań.

W następnym przykładzie zdefiniowano zadanie, które zawiera listę plików i podfolderów katalogu bin .

{
  "version": "0.2.1",
  "outDir": "\"${workspaceRoot}\\bin\"",
  "tasks": [
    {
      "taskName": "List Outputs",
      "appliesTo": "*",
      "type": "default",
      "command": "${env.COMSPEC}",
      "args": [ "dir ${outDir}" ]
    }
  ]
}
  • ${outDir} to makro niestandardowe, które jest najpierw zdefiniowane przed blokiem tasks . Następnie jest wywoływana args we właściwości .

To zadanie dotyczy wszystkich plików. Po otwarciu menu kontekstowego w dowolnym pliku w Eksplorator rozwiązań nazwa zadania Wyświetla dane wyjściowe listy w dolnej części menu. Po wybraniu pozycji Wyświetl dane wyjściowe zawartość katalogu bin zostanie wyświetlona w oknie Dane wyjściowe w programie Visual Studio.

Arbitrary task in context menu

zakres Ustawienia

Wiele plików tasks.vs.json może istnieć w katalogu głównym i podkatalogach bazy kodu. Ten projekt umożliwia elastyczne zachowanie w różnych podkatalogach bazy kodu. Program Visual Studio agreguje lub zastępuje ustawienia w całej bazie kodu, priorytetując pliki w następującej kolejności:

  • Ustawienia plików w katalogu .vs folderu głównego.
  • Katalog, w którym jest obliczane ustawienie.
  • Katalog nadrzędny bieżącego katalogu aż do katalogu głównego.
  • Ustawienia plików w katalogu głównym.

Te reguły agregacji dotyczą pliku tasks.vs.json. Aby uzyskać informacje na temat sposobu agregowania ustawień w innym pliku, zobacz odpowiednią sekcję dla tego pliku w tym artykule.

Właściwości pliku tasks.vs.json

W tej sekcji opisano niektóre właściwości, które można określić w pliku tasks.vs.json.

Appliesto

Zadania można tworzyć dla dowolnego pliku lub folderu, określając jego nazwę w appliesTo polu, na przykład "appliesTo": "hello.js". Następujące maski plików mogą być używane jako wartości:

Maska plików opis
"*" Zadanie jest dostępne dla wszystkich plików i folderów w obszarze roboczym
"*/" zadanie jest dostępne dla wszystkich folderów w obszarze roboczym
"*.js" zadanie jest dostępne dla wszystkich plików z rozszerzeniem .js w obszarze roboczym
"/*.js" zadanie jest dostępne dla wszystkich plików z rozszerzeniem .js w katalogu głównym obszaru roboczego
"src/*/" zadanie jest dostępne dla wszystkich podfolderów folderu src
"makefile" Zadanie jest dostępne dla wszystkich plików makefile w obszarze roboczym
"/makefile" zadanie jest dostępne tylko dla pliku makefile w katalogu głównym obszaru roboczego

Makra dla pliku tasks.vs.json

Makro opis
${env.<VARIABLE>} Określa dowolną zmienną środowiskową (na przykład ${env. PATH}, ${env. COMSPEC} i tak dalej), który jest ustawiony dla wiersza polecenia dewelopera. Aby uzyskać więcej informacji, zobacz Wiersz polecenia dla deweloperów i Program PowerShell dla deweloperów.
${workspaceRoot} Pełna ścieżka do folderu obszaru roboczego (na przykład C:\sources\hello)
${file} Pełna ścieżka pliku lub folderu wybranego do uruchomienia tego zadania (na przykład C:\sources\hello\src\hello.js)
${relativeFile} Ścieżka względna do pliku lub folderu (na przykład src\hello.js)
${fileBasename} Nazwa pliku bez ścieżki lub rozszerzenia (na przykład hello)
${fileDirname} Pełna ścieżka do pliku z wyłączeniem nazwy pliku (na przykład C:\sources\hello\src)
${fileExtname} Rozszerzenie wybranego pliku (na przykład .js)

Konfigurowanie debugowania przy użyciu pliku launch.vs.json

Aby skonfigurować projekty CMake do debugowania, zobacz Konfigurowanie sesji debugowania narzędzia CMake.

  1. Aby skonfigurować bazę kodu na potrzeby debugowania, w Eksplorator rozwiązań wybierz element menu Debuguj i Uruchom Ustawienia z menu kontekstowego lub kliknij prawym przyciskiem myszy plik wykonywalny.

    Debug and Launch Settings context menu

  2. W oknie dialogowym Wybieranie debugera wybierz opcję, a następnie wybierz przycisk Wybierz.

    Select a Debugger dialog box

    Jeśli plik launch.vs.json jeszcze nie istnieje, zostanie utworzony.

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

  3. Następnie kliknij prawym przyciskiem myszy plik wykonywalny w Eksplorator rozwiązań, a następnie wybierz polecenie Ustaw jako element startowy.

    Plik wykonywalny jest wyznaczony jako element startowy bazy kodu, a tytuł przycisku Start debugowania zmienia się w celu odzwierciedlenia nazwy pliku wykonywalnego.

    Customized Start button

    Po wybraniu klawisza F5 debuger uruchamia i zatrzymuje się w dowolnym punkcie przerwania, który mógł już zostać ustawiony. Wszystkie znane okna debugera są dostępne i funkcjonalne.

    Ważne

    Aby uzyskać dodatkowe szczegółowe informacje na temat niestandardowych zadań kompilacji i debugowania w projektach otwierania folderów języka C++, zobacz Obsługa otwierania folderów dla systemów kompilacji języka C++ w programie Visual Studio.

Określanie argumentów na potrzeby debugowania

Argumenty wiersza polecenia można określić do przekazania do debugowania w pliku launch.vs.json . Dodaj argumenty w tablicy args , jak pokazano w poniższym przykładzie:

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

Po zapisaniu tego pliku nazwa nowej konfiguracji zostanie wyświetlona na liście rozwijanej miejsca docelowego debugowania i możesz wybrać ją, aby uruchomić debuger. Możesz utworzyć dowolną liczbę konfiguracji debugowania.

Debug configurations drop-down list

Uwaga

Właściwość configurations tablicy w pliku launch.vs.json jest odczytywana z dwóch lokalizacji plików — katalogu głównego bazy kodu i katalogu .vs . Jeśli występuje konflikt, priorytet jest przypisywany wartości w pliku .vs\launch.vs.json.

Dodatkowe pliki ustawień

Oprócz trzech plików json opisanych w tym temacie program Visual Studio odczytuje również ustawienia z niektórych dodatkowych plików, jeśli istnieją w bazie kodu.

.vscode\settings.json

Program Visual Studio odczytuje ograniczone ustawienia z pliku o nazwie settings.json, jeśli znajduje się w katalogu o nazwie .vscode. Ta funkcja jest udostępniana dla baz kodu, które zostały wcześniej opracowane w programie Visual Studio Code. Obecnie jedynym ustawieniem odczytu z pliku .vscode\settings.json jest files.exclude, które filtruje pliki wizualnie w Eksplorator rozwiązań i z niektórych narzędzi wyszukiwania.

W bazie kodu możesz mieć dowolną liczbę plików .vscode\settings.json . Ustawienia odczyt z tego pliku są stosowane do katalogu nadrzędnego .vscode i wszystkich jego podkatalogów.

.gitignore

Pliki .gitignore służą do powiedzieć usłudze Git, które pliki mają być ignorowane. Oznacza to, które pliki i katalogi nie chcesz zaewidencjonować. Pliki .gitignore są zwykle dołączane jako część bazy kodu, dzięki czemu ustawienia mogą być udostępniane wszystkim deweloperom bazy kodu. Program Visual Studio odczytuje wzorce w plikach gitignore w celu wizualnego filtrowania elementów i z niektórych narzędzi wyszukiwania.

Ustawienia odczyt z pliku .gitignore są stosowane do katalogu nadrzędnego i wszystkich podkatalogów.

Powiązana zawartość