Utilisez l'outil de construction Grunt basé sur Node.js pour publier ASP.NET MVCprojects_node.js

Introduction aux grognements
Grunt est un outil de construction basé sur js et node.js. Depuis que node.js est devenu de plus en plus populaire au cours de cette période, grunt bénéficie d'un riche support communautaire open source et a produit de nombreux plug-ins. . Il existe également quelques plugins dispersés dans la communauté des nœuds. La construction est une expression large. La compréhension traditionnelle est la compilation, l'empaquetage et la copie. Aujourd'hui, à mesure que la technologie devient de plus en plus abondante, la construction inclut également le prétraitement des composants frontaux, tels que le prétraitement de sass et moins en css, css. , et js. Compression et fusion. Le plug-in Grunt peut très bien prendre en charge ces nouveaux concepts de construction et est plus adapté aux projets construits avec des technologies open source. Bien que Grunt soit davantage utilisé pour la construction de programmes, Grunt est essentiellement un outil d’exécution de tâches utilisé pour résoudre des tâches répétitives.

Premiers pas avec Grunt
Installer
Téléchargez et installez Node.js. Adresse de téléchargement

Vérifiez l'installation et affichez la version :

node -v

v0.10.25

Installez l'outil de ligne de commande grunt grunt-cli et utilisez -g pour l'installer globalement afin qu'il puisse être utilisé dans n'importe quel répertoire. La commande suivante ajoutera du grognement au chemin de recherche de votre système, vous pourrez donc utiliser cette commande dans n'importe quel répertoire.

npm install -g grunt-cli

A noter que sous linux ou mac, une erreur d'absence de permissions sera parfois signalée. Dans ce cas, il faudra ajouter un sudo devant

.

sudo npm install grunt-cli -g

Voir la version :

grunt –version

grunt-cli v0.1.13

Désinstaller. Si vous avez déjà installé Grunt globalement, supprimez-le d'abord.

npm uninstall -g grunt

grunt-cli est juste une interface de ligne de commande grunt, qui nécessite l'utilisation de grunt et de ses plug-ins. Le module grunt lui-même doit être installé dans le chemin du projet (généralement le répertoire racine du projet), ce qui nécessite le plug-in. en module. Chaque fois que la commande grunt est exécutée, elle recherchera le grunt installé localement via la commande nodejs require. Pour cette raison, vous pouvez exécuter des commandes grunt dans n'importe quel sous-répertoire. Si la cli trouve un grognement installé localement, elle chargera la bibliothèque grognement, appliquera la configuration que vous avez écrite dans GruntFile, puis effectuera les tâches correspondantes.

Fichier de configuration
package.json
package.json est utilisé pour enregistrer les modules de nœuds installés et requis dans le répertoire courant, par exemple :

{
 "name": "my-project-name",
 "version": "0.1.0",
 "author": "Your Name",

 "devDependencies": {
 "grunt": "~0.4.1"
 }
}

Vous pouvez créer ce fichier manuellement ou via la commande npm init et suivre les invites pour terminer la création du fichier package.json. Si vous avez créé le package.json manuellement, téléchargez et installez simplement les modules requis via npm install. Une fois le module installé, il sera enregistré dans le répertoire node_modules.

Si vous souhaitez ajouter les modules requis ultérieurement, utilisez la commande suivante pour mettre à jour le fichier package.json de manière synchrone

npm install <module> --save-dev

Gruntfile.js
Le statut de ce fichier est comme un Makefile. C'est un fichier qui guide les utilisateurs pour effectuer des tâches. Il doit configurer les paramètres requis par chaque module de plug-in, charger les plug-ins et définir les tâches. Pour plus d'informations sur Gruntfile, veuillez vous référer à ici. Il est recommandé aux lecteurs d'avoir une compréhension globale de Gruntfile avant de continuer.

Créer ASP.NET MVC avec Grunt
MSbuild
Avant d'utiliser Grunt pour créer des projets .NET, vous devez d'abord comprendre MSbuild. MSBuild est l'outil de Microsoft pour créer des programmes. Actuellement, Visual Studio utilise pleinement MSbuild pour compiler des projets. MSbuild se compose d'un outil msbuild, d'un ensemble de programmes de compilation ou de création et de fichiers XML. En fait, les fichiers de projet .sln et .csproj dans Visual Studio sont au format XML que msbuild peut reconnaître (ci-après appelé fichier de configuration msbuild. Visual Studio termine le travail de génération en appelant msbuild, et msbuild reconnaît les paramètres et les identifiants de comportement de génération). . Nous pouvons également appeler nous-mêmes msbuild via la ligne de commande.

Il existe deux concepts clés dans msbuild : Tâche et Propriété. La tâche est le point d'entrée pour que msbuild soit exécuté directement en tant que cible. Lors de l'exécution de msbuild, elle doit pointer vers la tâche par défaut, sinon vous devez spécifier quelle est la tâche cible. La propriété est une variable. Tout comme les variables d'un programme peuvent affecter l'exécution du programme, la propriété peut affecter le comportement de la construction.

Le fichier de configuration msbuild généré par VisualStudio est en fait très compliqué, en apparence, il n'y a que quelques liaisons montantes. Cependant, il importe certains fichiers de configuration prédéfinis dans le fichier actuel via l'importation, ce qui rend impossible la visualisation complète de la configuration complète. Recherchez l'élément clé de la tâche. Heureusement, il existe un outil qui peut être utilisé pour aider à analyser la structure du fichier de configuration msbuild.

De plus, lors de l'appel de msbuild, vous pouvez remplacer les propriétés et les tâches par défaut via les paramètres de ligne de commande. Par exemple, l'appel suivant indique que la tâche « Rebuild » est utilisée comme cible et que l'attribut Configuration est défini sur Debug :

msbuild ConsoleApplication1.csproj /target:Rebuild /property:Configuration=Debug

更多关于msbuild，请参考微软的文档

手动使用msbuild代替VisualStudio
以发布到本机为例，经过笔者在VS2012下的环境中测试，使用VS在调用msbuild时使用了如下关键的参数覆盖：

• Configuration：Debug或者Release，相信使用VS的同学对此不会陌生
• VisualStudioVersion：VS在安装的时候会将一些公用的，VisualStudio相关的，msbuild配置文件预先存在某个版本相关的地方，在VisualStudio生成项目文件时，会包含一个$VisualStudioVersion变量，这个变量会与路径结合指向这些预先准备好的配置文件。在2012下，需要将这个值设置为11.0
• WarningLevel：编译时的告警级别
• DeleteExistingFiles：发布功能使用到的是否删除已存在文件的选项
• WebPublishMethod：发布方式，笔者常用的是FileSystem，即发布到本机或远程共享的某个目录
• publishUrl：如果WebPublishMethod是FileSystem，这个值表示发布的磁盘路径

关键的任务：

• Build：即VS中针对某个项目的编译功能
• Rebuild：即VS中针对某个项目的重新编译功能
• WebPublish：即VS针对某个项目的发布功能

至此，我们已经可以使用msbuild命令行来代替VS的一些构建动作了。由于本篇的重点是grunt，读者可以参见微软的说明，自己试验一下：

PS: MSbuild通常位于类似这样的目录下：C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe
使用grunt-msbuild调用msbuild
终于到了介绍本文的主角了：grunt-msbuild。这是一个个人开发的msbuild调用中间件。作为grunt的插件，经过笔者亲测，完全可以使用。结合其他的grunt插件，简化了笔者发布项目的过程。

你可以像下面这样将这个插件添加进项目的Gruntfile，实现自动发布：

msbuild: {
  fontend: {    
    src: ['Web.FontEnd/Web.FontEnd.csproj'],
    options: {
      projectConfiguration: 'Release',
      targets: ['WebPublish'],
      stdout: true,
      maxCpuCount: 4,
      buildParameters: {
        WarningLevel: 2,
  VisualStudioVersion: "11.0",
  DeleteExistingFiles: 'True',
  WebPublishMethod: 'FileSystem',
  publishUrl: [font_pwd]
      },
      verbosity: 'quiet'
    }
  }
}

上面的代码实现了，将Web.FontEnd.csproj项目在Release模式下通过FileSystem发布方式发布到font_pwd变量指代的目录下。 这里需要注意的是，可能需要根据自己的VS版本修改VisualStudioVersion参数，可以通过查看类似如下目录：C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\v11.0来检查。font_pwd是一个js变量，根据需要进行调整。

Grunt的完整配置就不给出了，主要是要知道这几个关键的参数设置。

在实际使用过程中DeleteExistingFiles这个参数似乎不起作用，所以可能需要另外再包含清空目标文件夹的任务。下面是实际任务运行时的部分截图：