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.

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"
  },
  ...
}

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.

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

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.

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

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

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

"tasks": [
    {
        "taskName": "build",
        ...
    },
    {
         "taskName": "package",
         ...
    }
]

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]

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

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

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

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.

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

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.