Pourquoi devrais-je utiliser MSBuild au lieu des fichiers de solution Visual Studio?

Nous utilisons TeamCity pour une intégration continue et nous construisons nos versions via le fichier de solution (.sln). J'ai utilisé Makefiles dans le passé pour divers systèmes mais jamais msbuild (ce que j'ai entendu est en quelque sorte comme Makefiles + mashup XML). J'ai vu de nombreux articles sur la façon d'utiliser directement msbuild au lieu des fichiers de solution, mais je ne vois pas de réponse très claire sur les raisons de le faire.

Alors, pourquoi devrions-nous prendre la peine de migrer des fichiers de solution vers un «makefile» MSBuild? Nous avons quelques versions qui diffèrent par une # définition (versions personnalisées), mais pour la plupart, tout fonctionne.

La plus grande préoccupation est que nous devions maintenant maintenir deux systèmes lors de l'ajout de projets / code source.

MISE À JOUR:

Les gens peuvent-ils faire la lumière sur le cycle de vie et l'interaction des trois composants suivants?

1. Le fichier Visual Studio .sln
2. Les nombreux fichiers .csproj au niveau du projet (que je comprends un "ms" scripts msbuild)
3. Le script msbuild personnalisé

Est-il sûr de dire que les fichiers .sln et .csproj sont consommés / maintenus comme d'habitude à partir de l'interface graphique de Visual Studio IDE alors que le script msbuild personnalisé est écrit à la main et consomme généralement le .csproj individuel existant "tel quel"? C'est une façon dont je peux voir réduire les chevauchements / doublons dans la maintenance ...

J'apprécierais un peu la lumière de l'expérience opérationnelle d'autres personnes

Le premier point de fait est que le fichier de solution devient à peu près comme par magie un fichier MSBuild lorsque MSBuild l'exécute - ce qui se produit lorsque vous créez la solution dans Visual Studio. De plus, tous ces fichiers de projet ne sont que des fichiers msbuild gérés par Visual Studio. En fait, les fichiers de projet gèrent la plupart du vrai travail sale ici, peu importe si vous construisez à partir de solutions ou à partir d'un script msbuild personnalisé.

Nous utilisons également TeamCity pour créer et publier des applications et nous nous retrouverons généralement avec des scripts msbuild personnalisés pour la plupart des projets. Le rôle joué par ces scripts - ce qui n'est pas vraiment facile avec un fichier de solution - est d'empaqueter le projet pour le déploiement ou la distribution. En règle générale, ces scripts gèrent certains aspects plus opérationnels des choses, comme la création du projet Web dans un dossier particulier ou la copie dans les configurations en cours d'exécution par opposition aux configurations de développement. Le gros du travail a tendance à être géré dans les fichiers de projet eux-mêmes - le script de construction fait simplement référence à ceux-ci, nous n'essayons pas de recréer cette roue. Dans l'ensemble, cela fonctionne très bien et ce n'est pas vraiment du code en double.

Le makefile pour msbuild est le fichier .sln (ou fichier vcproj).

Une ligne de commande msbuild typique serait quelque chose comme:

msbuild /p:Configuration=Release BigProject.sln

Le but de l'utilisation de msbuild est que vous puissiez créer un script et automatiser le processus de construction. Que vous le sachiez ou non, TeamCity a toujours utilisé msbuild.

Permettez-moi de vous donner mon point de vue sur cette question.

Bien que vous puissiez certainement utiliser simplement votre fichier .SLN comme «processus de génération», le fichier lui-même ne constitue pas vraiment un processus de génération. Le fichier Solution n'est vraiment qu'une partie de Visual Studio et est utilisé pour le développement. Mais Visual Studio n'est qu'une partie du processus de génération et de publication. Vous ne pouvez pas compter sur Solutions pour gérer votre build, et les Solutions n'offrent certainement pas une situation de build évolutive.

Le but de l'établissement d'un processus de génération est de créer des versions fiables. C'est-à-dire que le processus de construction est si fiable que, quelle que soit la configuration de construction, vous obtiendrez une sortie de construction prévisible. Chaque fois, chaque machine. Le résultat d'une construction prévisible et fiable est que le processus de test, de déploiement et de publication peut alors être hautement automatisé, ce qui réduit encore plus le risque d'erreur humaine.

L'établissement d'un processus de construction nécessite un investissement, mais dans certains cas, l'investissement est requis. Voici quelques facteurs qui favorisent un processus msbuild:

• Votre produit a plusieurs équipes (interfonctionnelles ou autres) qui travaillent dans le même projet d'équipe
• Votre organisation n'a qu'un seul projet d'équipe (devrait être le cas pour 99% des magasins traditionnels, même ceux avec plus de 200 développeurs)
• Vous avez plus de 20 projets à construire, dont certains dépendent des autres et sont maintenus par différentes équipes
• Votre produit intègre plusieurs technologies .NET (C #, C ++, VB, F #, ASP.NET, etc.), voire des technologies non-NET (Grunt, node, npm, Java, etc.)
• Votre produit a des dépendances lourdes ou est construit sur une plate-forme lourde. SharePoint, par exemple

Permettez-moi de donner un exemple pour développer mon dernier point. Mon entreprise actuelle fait du développement SharePoint. Le développement de SharePoint au minimum nécessite que la fondation SharePoint soit installée pour effectuer des builds sur des projets SharePoint. S'agissant d'un serveur de build léger, il est complètement impossible d'exiger que le serveur de build ait installé SharePoint. Non seulement SharePoint est une bête avec des exigences élevées, mais cela aurait de sérieuses implications sur les performances d'une génération - et les générations sont censées être aussi rapides et allégées que possible. Tirer parti de MSBuild me permet d'éliminer cette exigence d'installation sur le serveur de génération. En fait, notre serveur de build n'a pas d'exigences d'installation autres que le framework .NET (requis par MSBuild) et Node.

Comme référence, je recommanderais de consulter ce livre de Sayed Ibrahim Hashimi: http://www.amazon.com/Inside-Microsoft-Build-Engine-Foundation/dp/0735645248/ref=sr_1_fkmr0_1?ie=UTF8&qid=1412014650&sr= 8-1-fkmr0 & mots-clés = msbuild + fiable + build

C'est exactement la question que je me suis posée il y a quelques mois! Nous avons tout bien installé:

• Fichier de solution joliment à la racine des référentiels
• Créez des étapes configurées dans Teamcity, comme
  • Restaurer les packages NuGet
  • Créer une solution
  • Exécuter des tests unitaires
  • Configuration de l'environnement de test d'intégration
  • Exécutez des tests d'intégration
  • Démolir l'environnement de test d'intégration
  • Créer un package de déploiement
  • Créer un script de migration

Et puis, en ce qui concerne la reproductibilité, il est devenu évident que ce score était faible. Lorsque vous laissez TeamCity être votre script de build, il devient difficile de reproduire des résultats similaires, fiables, sur votre propre machine de développement.

Lorsque vous avez un script de build, le script de build sait tout ce qui doit être fait et a toutes les variables en place. Lorsque vous utilisez un serveur CI comme script de génération et que certains problèmes se produisent, comme un test complexe échouant ou devant créer un package de déploiement manuellement (selon mon exemple), vous devez reconstituer manuellement toutes les étapes de la génération.

Donc, en bref , pourquoi un script de construction (MS)? Parce que vous finirez par avoir plus d'exigences en ce qui concerne votre construction. Vous voudrez probablement exécuter des tests et générer des artefacts à partir de cela. Vous souhaitez probablement effectuer des déploiements. Et lorsque tout ce que vous voulez doit être exécutable, que ce soit sur un serveur de build ou sur votre machine, il ne peut pas se retrouver ailleurs que dans un script de build.