Definieren Sie mehrere Aufgaben in VSCode

82

Ich habe gesehen, dass es möglich ist, eine Aufgabe im VSCode zu definieren. Ich bin mir jedoch nicht sicher, wie ich mehrere Aufgaben in der tasks.jsonDatei definieren soll.

visual-studio-code  vscode-tasks 
— Franz Gsell
quelle
13
Es ist ziemlich erstaunlich, wie schlecht die VS Code-Website dies erklärt! Man muss die dunklen Ecken des Internets durchsuchen, um herauszufinden, wie dieses neue Tool funktioniert.
— Kokodoko
In VS Code 1.9 (Januar 2017) wurde erstklassiger Support hinzugefügt, sodass die in den Top-Antworten hier aufgeführten Problemumgehungen nicht mehr erforderlich sind. Siehe diese Antwort (meine) .
— Vossad01
Eine Antwort finden Sie hier: stackoverflow.com/questions/43657839/…
— Pasx

Antworten:

36

Nur für den Fall, dass es jemandem hilft .... Wenn Sie nicht haben / wollen, dass gulp / grunt / etc ... oder ein zusätzliches Shell-Skript zum Proxy Ihrer Task-Befehle verwendet wird, ist "npm run" bereits vorhanden.

Dies ist für Webpack und Mokka wie in "Build and Test", Shift+ Ctrl+ B, Shift+ Ctrl+T

.vscode / task.json:

{
  "name": "npmTask",
  //...
  "suppressTaskName": true,
  "command": "npm",
  "isShellCommand": true,
  "args": [
    "run"
  ],
  "tasks": [
    {
      //Build Task
      "taskName": "webpack",
      //Run On Shift+Ctrl+B
      "isBuildCommand": true,
      //Don't run when Shift+Ctrl+T
      "isTestCommand": false,
      // Show the output window if error any
      "showOutput": "silent",
      //Npm Task Name
      "args": [
        "webpack"
      ],
      // use 2 regex:
      // 1st the file, then the problem       
      "problemMatcher": {
        "owner": "webpack",
        "severity": "error",
        "fileLocation": "relative",
        "pattern": [
          {
            "regexp": "ERROR in (.*)",
            "file": 1
          },
          {
            "regexp": "\\((\\d+),(\\d+)\\):(.*)",
            "line": 1,
            "column": 2,
            "message": 3
          }
        ]
      }
    },
    {
      //Test Task   
      "taskName": "mocha",
      // Don't run on Shift+Ctrl+B
      "isBuildCommand": false,
      // Run on Shift+Ctrl+T
      "isTestCommand": true,
      "showOutput": "always",
      "args": [
        "mocha"
      ]
    }
  ]
}

package.json:

{
  ...
  "scripts": {
    "webpack": "webpack",
    "mocha": "/usr/bin/mocha"
  },
  ...
}
— Dan
quelle
Schöne Lösung! Sie definieren also Ihre eigentlichen Befehle im Tag "npm scripts" und rufen dann das npm-Skript von task.json aus auf. Am liebsten hätte ich die Aufgaben direkt in task.json definiert. Das scheint ein bisschen überflüssig?
— Kokodoko
13

Was mir geholfen hat, dies besser zu verstehen, ist die Reihenfolge der Argumente, die an den Befehl übergeben wurden. Für manche mag es offensichtlich sein, aber es ist in der Dokumentation nicht klar.

Lassen Sie einige Felder weg, um sich nur auf den gesendeten Befehl zu konzentrieren:

{ "command": "myCommand"
  "args": ["myCommandArguments"],
  "tasks" : [ 
    { "taskName": "myTask",
      "args": ["myTaskArguments"],
      "suppressTaskName": false,
    }
  ]
}

Die obige Definition führt zu folgendem Befehl:

myCommand myCommandArguments myTaskArguments myTask

Der Aufgabenname myTaskist immer der letzte. Seit Version 0.4 kann es mit weggelassen werden "suppressTaskName": true.

— Hurelu
quelle
Wow, ich konnte diese Antwort nicht glauben, habe sie aber ausprobiert und sie war wahr und hat funktioniert. Ich wollte eine Aufgabe in VSCode für "gulp --no-color vet --verbose", aber um sie zum Laufen zu bringen, musste ich das Argument als Aufgabe und die Aufgabe als Argument wie "gulp --no-color" verwenden --verbose vet "in der task.json wobei vet meine Aufgabe ist und --verbose ein Argument ist. Dies führt natürlich zu Problemen mit Aufgaben, deren Argumente identisch sind. Daher wird die Aufgabe nach ihren Argumenten benannt und in den Optionen für die Ausführung von VSCode-Aufgaben als solche aufgeführt.
— GJSmith3rd
Aber was ist, wenn ich unterschiedliche Aufgaben mit unterschiedlichen Befehlen möchte? Zum Beispiel sollte eine Aufgabe node-sass ausführen und die andere tsc?
— Kokodoko
Sie haben mich vor dem Springen aus dem Fenster mit dem Argument "ignoreTaskName" bewahrt.
— Machinegon
12

Versuche dies

{
    "version": "0.1.0",
    "command": "cmd",
    "isShellCommand": true,
    "args": ["/C"],
    "tasks": [
        {
            "taskName": "install",
            "args": ["npm install"]
        },
        {
            "taskName": "build",
            "args": ["gulp build"],
            "isBuildCommand": true,
            "problemMatcher": "$gulp-tsc"
        }
    ]
}
— AlexStack
quelle
Weitere Infos bitte? Was ist der Fehler? Ich verwende dies ab VS Code 0.8.0 und es funktioniert gut.
— AlexStack
Bei der Google-Ausgabe wird die Standardausgabe von cmd.exe angezeigt. So: Microsoft Windows [Version 10.0.10240] (c) Microsoftорпорация Майкрософт (Microsoft Corporation), 2015 г. Все права защищены. // MS Urheberrechte an russischem C: \ Users \ roman>
— neftedollar
@neftedollar Dies funktioniert nur unter Windows. Wenn Sie nach etwas suchen, das auf einem Mac funktioniert, ändern Sie "command": "cmd" in "command": "sh" und "args": ["/ c"] in "args": ["- c "].
— ra9r
@raiglstorfer danke, es funktionierte nicht auf meinem Windows-PC.
— Neftedollar
10

Ich verwende die folgende Datei task.json, um mehrere TypeScript-Build-Szenarien auszuführen. Ich habe in jeden Ordner eine tsconfig.json-Datei eingefügt, damit ich die Ausgabe jedes Ordners einzeln optimieren kann. Stellen Sie einfach sicher, dass Sie den Aufgabennamen unterdrücken, da er versucht, ihn in die Befehlszeichenfolge einzufügen.

{
    "version": "0.1.0",
    "command": "tsc",
    "showOutput": "always",
    "isShellCommand": true,
    "args": [],
    "windows": {
        "command": "tsc",
        "showOutput": "always",
        "isShellCommand": true
    },
    "tasks": [
        {
            "taskName": "Build the examples",
            "suppressTaskName": true,
            "isBuildCommand": false,            
            "args": ["-p", "./source/examples", "--outDir", "./script/examples"],
            "problemMatcher": "$tsc"
        },
        {
            "taskName": "Build the solution",            
            "suppressTaskName": true,
            "isBuildCommand": false,        
            "args": ["-p", "./source/solution", "--outDir", "./script/solution"],
            "problemMatcher": "$tsc"
        }   
    ]
}

So sieht die Ordnerstruktur aus, wobei / script das Ausgabestammverzeichnis und / source das Eingabestammverzeichnis ist. Beide Ordner verweisen auf Typdeklarationen im Ordner / typingd und im Ordner / typings. TypeScript beschränkt sich in gewisser Weise auf die Verwendung relativer Pfade in externen Referenzen. Daher vereinfacht es die Dinge, wenn diese Ordnerstrukturen ähnlich sind.

TypeScript Multi-Build-Ordnerstruktur

Oh ja, es macht es einfacher, sie selektiv zu starten, wenn Sie sie als nicht erstellt markieren und den Build-Schlüssel überschreiben, um eine bestimmte Aufgabe aus einer Liste auszuwählen.

// Place your key bindings in this file to overwrite the defaults
[
    { "key": "ctrl+shift+b", "command": "workbench.action.tasks.runTask" }
]

Update : Sie können jederzeit einfach nur Schurken werden, wenn Sie möchten. Es gibt vielleicht bessere Möglichkeiten, mit den Argumenten umzugehen, aber das funktioniert im Moment unter OSX für mich.

{
  "version": "0.1.0",
  "isShellCommand": true,
  "linux": { "command": "sh", "args": ["-c"] },
  "osx": { "command": "sh", "args": ["-c"] },
  "windows": { "command": "powershell", "args": ["-Command"] },
  "tasks": [
    {
      "taskName": "build-models",
      "args": ["gulp build-models"],
      "suppressTaskName": true,
      "isBuildCommand": false,
      "isTestCommand": false
    },
    {
      "taskName": "run tests",
      "args": ["mocha ${workspaceRoot}/test"],
      "suppressTaskName": true,
      "isBuildCommand": false,
      "isTestCommand": false
    }
  ]
}
— Djabraham
quelle
2
Dies ist ein sehr klares Beispiel! Dies ist wahrscheinlich die Absicht von MS, die task.json zu verwenden (schade, dass sie dies nicht selbst erklären). Das einzige Problem ist: Was ist, wenn ich VERSCHIEDENE Befehlszeilenaufgaben habe? (Ich brauche eine Tsc-Aufgabe und eine Node-Sass-Aufgabe)
— Kokodoko
3
Unter Aktualisieren finden Sie Informationen zum Ausführen mehrerer unabhängiger Befehle.
— Djabraham
Ich bin damit einverstanden, dass ein einzelner "Build-Befehl" Probleme bereitet, wenn Sie tsc und node-sass verwenden möchten. Das Installieren und Erlernen eines Build-Tools eines Drittanbieters (wie gulp) ist ein Wermutstropfen. Es ist ein Wermutstropfen, verschiedene Befehlsprozessoren für verschiedene Betriebssysteme auflisten zu müssen.
— Jon Watte
7

Ich kenne die richtige Antwort darauf nicht (und würde es auch gerne wissen), aber meine hässliche Problemumgehung, falls es jemandem hilft. Ich bin unter Windows und habe mir selbst ein einfaches Batch-Skript erstellt, das einfach enthalten könnte

"%1" "%2"

Dann sieht meine Task.json so aus

{
    "version": "0.1.0",
    "command": "c:\\...\\mytasks.bat"
    "tasks" : [
        {
            "taskName": "myFirstTask",
            "args": "c:\\...\\task1.exe", "${file}"],
        },
        {
            "taskName": "mySecondTask",
            "args": "c:\\...\\task2.exe", "${file}"],
        },
    ]
}
— Jonathan Corwin
quelle
Ich habe es endlich geschafft. Irgendwann in den letzten 9 Monaten hat VS Code begonnen, den TaskName zu Argument 1 für die Task hinzuzufügen. Meine Batch-Datei lautet also: "% 2" "% 3" anstelle dessen, was Sie haben. Wenn dies konsistent bleibt, komme ich möglicherweise zurück, um diese Lösung zu bearbeiten.
— Phil
6

Sie können mehr als eine Aufgabe in der Aufgabeneigenschaft auflisten. Etwas wie:

"tasks": [
    {
        "taskName": "build",
        ...
    },
    {
         "taskName": "package",
         ...
    }
]
— Dirk Bäumer
quelle
7
Sie müssen jedoch denselben Befehl verwenden. Sie können nur die Argumente variieren.
— Edward B.
Ja, Edward B. aus irgendeinem Grund geht jeder aktuelle Blog-Beitrag davon aus, dass Sie gerade erst mit VS Code beginnen und noch keine Aufgaben haben: S. Sie müssen jedoch auf dem Stammknoten den Wert "replaceTaskName": true festlegen und können ihn dann in den Unteraufgaben auf "taskName" setzen, um verschiedene Befehle verwenden zu können. Siehe Beispiel für @Dan mit tscund mochaAufgaben.
— Bart
4

Diese Funktionalität wurde in Visual Studio Code v1.9 (Januar 2017) hinzugefügt . Beispiel und Text stammen aus den Versionshinweisen :

{
  "version": "0.1.0",
  "tasks": [
    {
      "taskName": "tsc",
      "command": "tsc",
      "args": ["-w"],
      "isShellCommand": true,
      "isBackground": true,
      "problemMatcher": "$tsc-watch"
    },
    {
      "taskName": "build",
      "command": "gulp",
      "args": ["build"],
      "isShellCommand": true
    }
  ]
}

Befehle pro Aufgabe

Sie können jetzt verschiedene Befehle pro Aufgabe definieren ( # 981 ). Auf diese Weise können Sie verschiedene Befehle für verschiedene Aufgaben ausführen, ohne ein eigenes Shell-Skript schreiben zu müssen. Eine tasks.jsonDatei, die Befehle pro Aufgabe verwendet, sieht wie folgt aus: [oben]

— vossad01
quelle
3

Dies scheint ein VSCode-Fehler ab Version 0.5.0 zu sein

Deshalb habe ich diese Antwort hinzugefügt, um ein funktionierendes Beispiel für das zu zeigen, was zuvor von @hurelu erklärt wurde. Meine Aufgaben.json:

{
    "version": "0.1.0",
    "command": "gulp",
    "isShellCommand": true,
    "args": [
        "--no-color"
    ],
    "tasks": [
        {
            "taskName": "--verbose",
            "isBuildCommand": true,
            "showOutput": "always",
            "args": [
                "vet"
            ],
            "problemMatcher": [
                "$jshint",
                "$jshint-stylish"
            ]
        },
        {
            "taskName": "vet",
            "isTestCommand": true,
            "showOutput": "always",
            "args": [],
            "problemMatcher": [
                "$jshint",
                "$jshint-stylish"
            ]
        }
    ]
}

Meine gulp.js:

/// <reference path="typings/tsd.d.ts" />

var gulp = require('gulp');
var jshint = require('gulp-jshint');
var jscs = require('gulp-jscs');
var util = require('gulp-util');
var gulpprint = require('gulp-print');
var gulpif = require('gulp-if');
var args = require('yargs').argv;

gulp.task('vet', function () {
    log('Analyzing source with JSHint and JSCS');

    return gulp
        .src
        ([
            './src/**/*.js',
            './*.js'
        ])
        .pipe(gulpif(args.verbose, gulpprint()))
        .pipe(jscs())
        .pipe(jshint())
        .pipe(jshint.reporter('jshint-stylish', { verbose: true }))
        .pipe(jshint.reporter('fail'));
});

gulp.task('hello-world', function () {
    console.log('This is our first Gulp task!');
});

////////////
function log(msg) {
    if (typeof (msg) === 'object') {
        for (var item in msg) {
            if (msg.hasOwnProperty(item)) {
                util.log(util.colors.blue(msg[item]));
            }
        }
    } else {
        util.log(util.colors.blue(msg));
    }

}

Beachten Sie, dass die erste Aufgabe isBuildCommand verwendet, sodass STRG + SHFT + B gestartet wird, und die nächste Aufgabe isTestCommand ist, sodass STRG + SHFT + T gestartet wird. Um jedoch die erste Aufgabe zu erhalten, die Argumente akzeptiert, mussten der Aufgabenname und die Argumente umgekehrt werden.

Ab VSCode 0.5.0 funktioniert das oben Genannte, das Folgende jedoch nicht:

{
    "version": "0.1.0",
    "command": "gulp",
    "isShellCommand": true,
    "args": [
        "--no-color"
    ],
    "tasks": [
        {
            "taskName": "vet",
            "isBuildCommand": true,
            "showOutput": "always",
            "args": [
                "--verbose"
            ],
            "problemMatcher": [
                "$jshint",
                "$jshint-stylish"
            ]
        },
        {
            "taskName": "vet",
            "isTestCommand": true,
            "showOutput": "always",
            "args": [],
            "problemMatcher": [
                "$jshint",
                "$jshint-stylish"
            ]
        }
    ]
}

Hier ist die Ausgabe von task.json mit der richtigen Reihenfolge der Aufgaben und Argumente:

[10:59:29] Using gulpfile ~/Workspaces/Examples/Gulp/pluralsight-gulp/gulpfile.js
[10:59:29] Task 'default' is not in your gulpfile
[10:59:29] Please check the documentation for proper gulpfile formatting

Hier ist die korrekte Ausgabe aus der Datei task.json, wobei der Aufgabenname und das Argument bei Verwendung von Argumenten umgekehrt sind:

[11:02:44] Using gulpfile ~/Workspaces/Examples/Gulp/pluralsight-gulp/gulpfile.js
[11:02:44] Starting 'vet'...
[11:02:44] Analyzing source with JSHint and JSCS
[gulp] src/server/app.js
[gulp] src/client/app/app.module.js
[gulp] src/client/test-helpers/bind-polyfill.js
[gulp] src/client/test-helpers/mock-data.js
[gulp] src/server/routes/index.js
[gulp] src/client/app/core/config.js
[gulp] src/client/app/core/constants.js
[gulp] src/client/app/core/core.module.js
[gulp] src/client/app/core/dataservice.js
[gulp] src/client/app/core/dataservice.spec.js
[gulp] src/client/app/customers/customer-detail.controller.js
[gulp] src/client/app/customers/customer-detail.controller.spec.js
[gulp] src/client/app/customers/customers.controller.js
[gulp] src/client/app/customers/customers.controller.spec.js
[gulp] src/client/app/customers/customers.module.js
[gulp] src/client/app/customers/customers.route.js
[gulp] src/client/app/customers/customers.route.spec.js
[gulp] src/client/app/dashboard/dashboard.controller.js
[gulp] src/client/app/dashboard/dashboard.controller.spec.js
[gulp] src/client/app/dashboard/dashboard.module.js
[gulp] src/client/app/dashboard/dashboard.route.js
[gulp] src/client/app/dashboard/dashboard.route.spec.js
[gulp] src/client/app/layout/ht-sidebar.directive.js
[gulp] src/client/app/layout/ht-sidebar.directive.spec.js
[gulp] src/client/app/layout/ht-top-nav.directive.js
[gulp] src/client/app/layout/layout.module.js
[gulp] src/client/app/layout/shell.controller.js
[gulp] src/client/app/layout/shell.controller.spec.js
[gulp] src/client/app/layout/sidebar.controller.js
[gulp] src/client/app/layout/sidebar.controller.spec.js
[gulp] src/client/app/widgets/ht-img-person.directive.js
[gulp] src/client/app/widgets/ht-widget-header.directive.js
[gulp] src/client/app/widgets/widgets.module.js
[gulp] src/client/tests/server-integration/dataservice.spec.js
[gulp] src/server/routes/utils/errorHandler.js
[gulp] src/server/routes/utils/jsonfileservice.js
[gulp] src/client/app/blocks/exception/exception-handler.provider.js
[gulp] src/client/app/blocks/exception/exception-handler.provider.spec.js
[gulp] src/client/app/blocks/exception/exception.js
[gulp] src/client/app/blocks/exception/exception.module.js
[gulp] src/client/app/blocks/logger/logger.js
[gulp] src/client/app/blocks/logger/logger.module.js
[gulp] src/client/app/blocks/router/router-helper.provider.js
[gulp] src/client/app/blocks/router/router.module.js
[gulp] gulpfile.js
[gulp] karma.conf.js
[11:02:48] Finished 'vet' after 4.37 s
— GJSmith3rd
quelle
2

Ab der Version vom Februar 2017 können Sie Terminal Runner verwenden und mehrere Aufgaben erstellen, indem Sie Abhängigkeitsaufgaben einrichten. Es ist insofern etwas funky, als es für jede Aufgabe ein separates integriertes Terminal öffnet, das Sie beobachten müssen, um zu sehen, ob die Dinge funktionieren, und daran denken, sie zu schließen (sie "stapeln"), und Sie erhalten keine Benachrichtigung "erledigt" , aber es erledigt den Job. Die Funktionalität ist vorläufig, aber vielversprechend. Hier ist ein Beispiel zum Ausführen von tsc und jspm für eine Cordova-App.

{
// See https://go.microsoft.com/fwlink/?LinkId=733558
// for the documentation about the tasks.json format
"version": "2.0.0",
"tasks": [{
        "taskName": "tsc",
        "command": "tsc",
        "isShellCommand": true,
        "args": ["-p", "."],
        "showOutput": "always",
        "problemMatcher": "$tsc"
    }, {
        "taskName": "jspm",
        "command": "jspm",
        "isShellCommand": true,
        "args": ["bundle-sfx", "www/app/main.js", "www/dist/bundle.js", "--inline-source-maps", "--source-map-contents"],
        "showOutput": "always"
    },
    {
        "taskName": "build",
        "isBuildCommand": true,
        "dependsOn": ["tsc", "jspm"]
    }]
}
— Jason
quelle
Bestnoten für die Verwendung einer späteren Aufgabenversion. Macht die Sache viel einfacher!
— Wonea
1

Folgendes hat bei mir funktioniert:

task.json:

{
    "version": "0.1.0",
    "command": "cmd",
    "isShellCommand": true,
    "args": [
        "/c"
    ],
    "tasks": [
        {
            "taskName": "bower",
            "args" : ["gulp bower"],
            "isBuildCommand": true,
            "showOutput": "always"
        },
        {
            "taskName": "unittest",
            "suppressTaskName": true,
            "args" : ["dnx -p ${cwd}\\test\\MyProject.UnitTests test"],
            "isTestCommand": true,
            "showOutput": "always"
        }
    ]
}

MyProject.UnitTests \ project.json :

 "commands": {
    "test": "xunit.runner.dnx"
  }

Führen Sie die Laube aus: Strg + Umschalt + B vom vscode aus. Führen Sie die Tests aus: Strg + Umschalt + T vom vscode

— AlexandruC
quelle
1

Das funktioniert bei mir ...

Ich weiß, dass es hier viele verschiedene Antworten gibt, aber mein Ansatz war wieder ein bisschen anders, also dachte ich, ich würde meinen Wert von 2 Pence hinzufügen.

Ich bin unter Windows und verwende eine externe Batch-Datei, um meine Befehle auszuführen. Es ist ähnlich wie Jonathans Antwort oben, aber ich leite keine Befehle an sie weiter, was bedeutet, dass meine Datei "task.json" anders ist.

Ich könnte diesen Ansatz im Laufe der Zeit ändern (zum Beispiel habe ich noch nicht mit Schlucken gespielt), aber diese Methode funktioniert im Moment perfekt für mich.

Ich benutze Lenker für HTML-Vorlagen, Babel, damit ich ES6-Code und einen Code-Linter verwenden kann, um Fehler zu erkennen. Am Ende startet die Batch-Datei einen Browser mit meiner Startseite (index.html).

Hier ist meine Batch-Datei mit dem Namen run_tasks.bat:

@ECHO OFF
@ECHO Startz!
@ECHO Running Handlebars!

call handlebars html_templates -e html -f dist/html_templates.js

@ECHO Linting ES6 code

call eslint -c eslint.json src

@ECHO Running Babel ES6 to ES5

call babel src --out-dir dist --source-maps

@ECHO Now startzing page up in browser!
index.html

@ECHO Donezz it!

Und hier ist meine Task.json-Datei:

{ 
    "version": "0.1.0",
    "command": "${workspaceRoot}/run_tasks.bat",
    "isShellCommand": true,
    "isWatching": true,
    "showOutput": "always",

    "args": [],

    "tasks": [
        {
            "taskName": "build",
            "isBuildCommand": true,
            "isWatching": true,
            "showOutput": "always"
        }
}

Dann drücke ich in VSCode "STRG + UMSCHALT + B", um meine Batch-Datei auszuführen.

— Ocean Airdrop
quelle
1

Ich habe eine Electron-App, die weniger Stylesheet kompilieren muss, um das Programm zu erstellen und zu starten. Ich habe die Lösung von @ Ocean verwendet, die für mich funktioniert hat ... sonst hat nichts funktioniert.

Sowohl meine Datei task.json als auch die Datei build-task.bat befinden sich im Verzeichnis .vscode im Stammverzeichnis des Projekts.

build-task.bat

@ECHO OFF
@ECHO Begin!
@ECHO Compiling Less

call lessc ./css/styles.less ./css/styles.css

@ECHO Build Electron App and Launch

call electron ./app.js

@ECHO Finished!

task.json

{
    "version": "0.1.0",
    "command": "${workspaceRoot}\\.vscode\\build-tasks.bat",
    "isShellCommand": true,
    "isWatching": true,
    "showOutput": "always",

    "args": [],

    "tasks": [
        {
            "taskName": "build",
            "isBuildCommand": true,
            "isWatching": true,
            "showOutput": "always"
        }
    ]
}
— lamarant
quelle
0

Dank dieses Threads habe ich jetzt c # / dnxcore50 Build- und Test-Debug usw., die in vscode auf osx damit arbeiten: 

{
"version": "0.1.0",
"command": "bash",
"args": [
],
"tasks": [
    {
        "taskName": "xbuild",
        "args": [
            "./src/Service.Host/Service.Host.csproj"
        ],          

        "showOutput": "always",
        "problemMatcher": "$msCompile",
        "isBuildCommand": true
    },
    {
        "taskName": "dnx",
        "args" : ["-p", "./test/Service.Tests.Unit", "test"],
        "isTestCommand": true,
        "showOutput": "always"    
    }      
]
}

Ich bin sicher, Linux wäre im Grunde das gleiche. Das einzige, was mich ärgert, ist, dass ich die .csproj-Dateien nur zum Debuggen pflegen muss. Ich freue mich auf eine Möglichkeit, mit dnx zu debuggen, obwohl ich seit einigen Wochen nicht mehr gesucht habe.

— Mark Jones
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.