NAnt ou MSBuild, lequel choisir et quand?

Je suis conscient qu’il existe d’autres questions liées à NAnt et à MSBuild sur le dépassement de stack, mais je n’ai pas pu trouver de comparaison directe entre les deux et voici la question.

Quand faut-il choisir NAnt sur MSBuild? Lequel est le meilleur pour quoi? NAnt est-il plus adapté aux projets home / open source et MSBuild aux projets de travail? Quelle est l’expérience avec l’un des deux?

    J’ai fait une enquête similaire cette semaine. Voici ce que j’ai pu déterminer:

    NAnt:

    • Cross-platform (supporte Linux / Mono). Il peut être utile d’installer un site Web sur plusieurs cibles (Linux Apache et Windows IIS, par exemple).
    • 95% de syntaxe similaire à Ant (facile pour les utilisateurs Ant actuels ou les générateurs Java)
    • Intégration avec NUnit pour l’exécution de tests unitaires dans le cadre de la construction, et avec NDoc pour la documentation de production.

    MSBuild:

    • Intégré à .NET.
    • Intégré à Visual Studio
    • Facile à démarrer avec MSBuild dans Visual Studio – tout est dans les coulisses. Si vous voulez approfondir, vous pouvez modifier les fichiers manuellement.

    Différences subjectives: (YMMV)

    • La documentation NAnt est un peu plus simple. Par exemple, la liste de références de tâches MSBuild “Csc Task – Décrit la tâche Csc et ses parameters” (merci pour “help”?), Par rapport à la référence de tâche NAnt “csc – Comstack les programmes C #”. MISE À JOUR: J’ai remarqué que la documentation MSBuild a été améliorée et qu’elle est bien meilleure maintenant (probablement à égalité avec NAnt).
    • Pas facile de savoir comment éditer la source du script de génération (fichier *. * Proj) directement depuis Visual Studio. Avec NAnt, Visual Studio traite le script .build comme un fichier XML.
    • Apparemment, dans Visual Studio, les projets d’application Web n’obtiennent pas un fichier *. * Proj par défaut, alors j’ai eu beaucoup de mal à comprendre comment faire en sorte que MSBuild s’exécute sur le mien pour créer un script de déploiement.
    • NAnt n’est pas intégré à Visual Studio et doit être ajouté, soit avec un complément, soit en tant qu ‘”outil externe”. C’est un peu pénible à mettre en place.
    • (Modifier 🙂 Un de mes collègues a soulevé la question – si vous souhaitez configurer une machine de génération à l’aide de CruiseControl pour une continuous integration, CruiseControl s’intègre parfaitement à NAnt. UPDATE: CruiseControl a également une tâche MSBuild .
    • S’il vous plaît voir les commentaires ci-dessous pour une discussion complète et à jour sur les différences subjectives.

    L’un des principaux attraits de MSBuild pour moi (sur les plates-formes Windows) est qu’il fait partie intégrante de .NET lui-même. Cela signifie que MSBuild sera disponible sur toute machine Windows à jour avec Windows Update. Ajoutez à cela le fait que le compilateur C # fait également partie de .NET lui-même et que vous avez une plate-forme capable de construire des projets sur des machines propres. Il n’est pas nécessaire d’installer Visual Studio Behemoth. NAnt, d’autre part, doit être explicitement installé avant qu’une génération puisse être déclenchée.

    Juste pour mémoire, j’ai utilisé NMake, Make, Ant, Rake, NAnt et MSBuild sur des versions non sortingviales du passé (dans cet ordre). Mon préféré est MSBuild, haut la main (et je ne le préfère pas parce que “c’est ce que Visual Studio utilise”). IMHO, c’est un outil de construction très sous-estimé.

    Je comparerais NAnt vs MSBuild à la différence entre la programmation procédurale et fonctionnelle. NAnt est assez simple et vous obtenez ce que vous voyez. MSBuild nécessite par contre un peu plus de reflection. La courbe d’apprentissage est plus raide. Mais une fois que vous l’avez “compris”, vous pouvez faire des choses incroyables.

    Je recommanderais donc de regarder MSBuild si vous êtes également intéressé par une programmation de style fonctionnel ou logique – si vous êtes prêt à investir un peu de temps et d’efforts avant de voir des résultats tangibles (bien sûr, je crois fermement que cet investissement finira par porter ses fruits et que vous peut faire des choses plus puissantes plus efficacement).

    Personnellement, j’utilise les deux – pour le même projet.

    MSBuild est idéal pour créer des solutions et des projets Visual Studio.

    NAnt est plus facilement modifiable à la main, à mon avis – en particulier si vous connaissez déjà Ant. NAnt peut appeler MSBuild très facilement avec NAntConsortingb. Donc, je crée manuellement un script NAnt pour faire des choses telles que la copie de fichiers construits, le nettoyage, etc. – et appeler MSBuild pour faire la véritable partie “transformer mon code source C # en assemblys”.

    Si vous voulez un exemple de cela, regardez mon fichier de construction Protocol Buffers . (Je ne prétends pas que c’est un script NAnt fabuleux, mais ça fait l’affaire.)

    NAnt a plus de fonctionnalités prêtes à l’emploi , mais MSBuild a une structure fondamentale bien meilleure (les métadonnées des objects sont très importantes), ce qui facilite beaucoup la création de scripts MSBuild réutilisables.

    MSBuild prend du temps à comprendre, mais une fois que c’est fait, c’est très bien.

    Matériel d’apprentissage:

    • À l’intérieur du moteur de génération Microsoft: utilisation de MSBuild et de Team Foundation Build
      par Sayed Ibrahim Hashimi (janvier 2009)
    • Déploiement d’applications .NET: apprentissage de MSBuild et de ClickOnce par Sayed
      par Y. Hashimi (sept. 2008)

    KISS = Utiliser MSBuild.

    Pourquoi append quelque chose d’autre dans le mix quand vous avez quelque chose qui fera un travail raisonnable? Lorsque MSBuild est arrivé, NAnt est mort. Et Mono aura une implémentation MSBuild, ( xbuild ).

    DRY = Utiliser MSBuild.

    Demandez-vous ce que vous voulez d’un système de construction? Je veux un système de construction qui est également utilisé par mon IDE plutôt que de maintenir deux configurations différentes.

    Personnellement, j’adorerais entendre de vrais arguments pour NAnt, car je ne peux pas penser à ceux qui retiennent vraiment l’eau.

    Une chose que j’ai remarquée, c’est que plusieurs affiches mentionnent avoir à modifier les fichiers .csproj (ou .vbproj, etc.).

    MSBuild permet la personnalisation de ces fichiers. * Pro par l’utilisation de fichiers .user. Si j’ai un projet nommé MyCreativelyNamedProject.csproj et que vous souhaitez personnaliser les tâches MSBuild à l’intérieur, je peux créer un fichier nommé MyCreativelyNamedProject.csproj.user et utiliser CustomBeforeMicrosoftCommonTargets et CustomAfterMicrosoftCommonTargets pour personnaliser ces fichiers.

    De plus, NAnt et MSBuild peuvent être personnalisés au contenu du cœur par le biais de tâches MSBuild personnalisées et d’extensions NantConsortingb.

    Donc, utiliser NAnt ou MSBuild revient vraiment à la familiarité:

    • Si vous connaissez déjà Ant, utilisez NAnt. La courbe d’apprentissage sera très facile.
    • Si vous ne connaissez pas ces outils, MSBuild est déjà intégré à Visual Studio et ne nécessite aucun outil supplémentaire.

    Il est également utile d’append que MSBuild est quasiment assuré de fonctionner avec toutes les nouvelles versions de .NET et Visual Studio dès leur publication, alors que NAnt peut avoir un certain retard.

    J’utilise les deux en ce sens que mes scripts NAnt appellent MSBuild. Ma principale raison de restr avec NAnt est l’ isolement . Laissez-moi vous expliquer pourquoi je pense que c’est important:

    1. Ajouter des dépendances à votre projet. Le fichier de construction NAnt est étranger à Visual Studio (dans mon cas, je considère cela comme un pro), donc Visual Studio ne tente rien avec lui. Les tâches MSBuild sont intégrées à la solution et peuvent faire référence à d’autres tâches MSBuild. J’ai reçu le code source de quelqu’un d’autre pour savoir que je ne pouvais pas générer, car les tâches de la communauté MSBuild n’étaient pas installées. Ce que je trouve particulièrement frustrant, c’est que Visual Studio ne construise pas et ne jette pas un tas d’erreurs qui me font perdre du temps pour le débogage. Ceci, malgré le fait que la construction demandée aurait pu être lancée (en tant que compilation de débogage par exemple) sans certains des extras de la tâche MSBuild. En bref: je n’aime pas append des dépendances à mon projet si je peux l’éviter .

    2. Je ne fais pas confiance à Visual Studio pour autant que je puisse lancer son équipe de développement. Cela remonte aux débuts de Visual Studio quand il aurait massacré mon HTML. Je n’utilise toujours pas le concepteur par exemple (lors d’une conférence, j’ai récemment constaté que les collègues faisaient de même). J’ai constaté que Visual Studio peut bloquer des dépendances et des numéros de version dans le fichier DLL (je ne peux pas répliquer cela, mais cela s’est produit de manière cohérente dans un projet et a causé beaucoup de chagrin et de temps perdu). J’ai eu recours à une procédure de construction qui utilise Visual Studio pour construire en mode débogage uniquement. Pour la production, j’utilise NAnt pour contrôler tout en externe . Visual Studio ne peut plus interférer si je crée en utilisant NAnt.

    PS: Je suis développeur web et je ne fais pas de développement Windows Forms.

    Même si je ne connais pas très bien MsBuild, j’ai l’impression que certaines des principales différences des deux côtés peuvent être complétées par des ajouts:

    • MsBuildTasks
    • NantConsortingb

    J’ai récemment dû construire un projet Silverlight à Nant. J’ai découvert que la vie serait plus facile si je faisais cela avec MsBuild – j’ai fini par appeler une tâche MsBuild depuis un script Nant, donc je suppose que ce n’est pas trop ordinaire de mélanger les deux.

    Au-delà de cela, je suppose que cela va être une question de préférence personnelle – de toute évidence, vous pouvez gérer la plupart des fonctionnalités de MsBuild depuis Visual Studio, si c’est ce que vous voulez. Nant semble plus flexible et mieux adapté si vous préférez écrire des scripts à la main, et si vous venez du monde Java, vous serez probablement à l’aise avec lui.

    J’ai fini par utiliser les deux. Lors de la refonte de notre système de construction, j’étais confronté à un problème délicat. A savoir, je ne pouvais pas me débarrasser de .vcproj (et de la famille) car nous utilisions tous VS pour mettre à jour les fichiers de projet, les parameters et les configurations. Donc, sans un processus énorme de duplication et d’erreurs, nous ne pouvions pas baser notre système de construction sur un nouvel ensemble de fichiers.

    Pour cette raison, j’ai décidé de conserver les fichiers ‘proj’ de VS et d’utiliser MSBuild (ce sont des fichiers MSBuild, au moins VS2005 et VS2008 utilisent des fichiers de projet MSBuild). Pour tout le rest (configuration personnalisée, tests unitaires, conditionnement, préparation de la documentation …), j’ai utilisé NAnt.

    Pour une continuous integration, j’ai utilisé CruiseControl. Nous avions donc des scripts CC qui déclenchaient les travaux NAnt, qui pour la construction utilisaient MSBuild.

    Une dernière remarque: MSBuild ne supporte PAS les projets d’installation! Donc, vous êtes bloqué à appeler DevEnv.com ou à utiliser Visual Studio directement. C’est ce que j’ai fini par faire, mais j’ai désactivé le projet d’installation par défaut de toutes les configurations de solution, car les développeurs n’auraient normalement pas besoin de les construire, et s’ils le font, ils peuvent sélectionner manuellement leur génération.

    Je suis passé de NAnt à MSBuild récemment en raison de sa capacité à créer des solutions VS. J’utilise toujours NAnt occasionnellement, cependant.

    Vous pouvez également vouloir vérifier les tâches de la communauté MSBuild qui sont comme NAntConsortingb.

    La documentation et les didacticiels disponibles pour NAnt facilitent l’apprentissage des scripts de génération avec NAnt. Une fois que j’ai compris NAnt et créé des scripts de construction, j’ai commencé à traduire cette connaissance par MSBuild (j’ai fait X dans NAnt, comment puis-je faire X dans MSBuild?). La documentation de Microsoft suppose généralement un niveau de connaissance assez élevé avant qu’elle ne soit utile.

    La raison du passage de NAnt à MSBuild est que MSBuild est plus actuel. Malheureusement, la dernière version de NAnt date du 8 décembre 2007, alors que MSBuild 4.0 (.NET 4.0) n’est pas loin. On dirait que le projet NAnt est mort.

    Si vous trouvez une bonne documentation pour quelqu’un qui commence tout juste à apprendre à créer des scripts de génération à l’aide de MSBuild, ignorez NAnt et allez directement à MSBuild. Si NAnt sortait avec une nouvelle version, alors je penserais à restr avec NAnt, mais ils sont à la traîne maintenant.

    Nous utilisons les deux. NAnt est responsable de tous les éléments de “script”, tels que la copie, le déploiement sur IIS , la création de packages et MSBuild est responsable de la construction de la solution. Ensuite, nous pouvons éviter les problèmes avec .NET 4.0 non pris en charge par une nouvelle version de NAnt.

    NAnt est également plus évolutif. Si nous voulons migrer les scripts de déploiement vers les serveurs de production, nous ne copions que le fichier de génération et installons une version correcte de .NET – pas de problèmes Visual Studio avec les fichiers csproj 🙂

    YDeliver by Manoj est un framework de construction basé sur PSake. Il possède un ensemble complet de fonctions de bibliothèque, la capacité de définir des stream de travail et nous l’avons utilisé pour fournir plus de six projets d’entreprise à la production.

    Utilisez-le conjointement avec TeamCity , CruiseControl , ou tout ce qui peut faire fonctionner PowerShell .

    Nous utilisons FlubuCore. C’est une bibliothèque C # open source pour la construction de projets et l’exécution de scripts de déploiement à l’aide du code C #.

    Exemple simple d’utilisation de flubu:

    protected override void ConfigureTargets(ITaskContext session) { var comstack = session.CreateTarget("comstack") .SetDescription("Comstacks the solution.") .AddTask(x => x.ComstackSolutionTask()) .DependsOn("generate.commonassinfo"); } 

    Vous pouvez trouver plus d’informations sur flubu et comment commencer ici: choice-for-build-tool-msbuild-nant-or-else-else