NAnt o MSBuild, ¿cuál elegir y cuándo?

160

Soy consciente de que hay otras preguntas relacionadas con NAnt y MSBuild sobre Stack Overflow, pero no pude encontrar una comparación directa entre las dos y aquí está la pregunta.

¿Cuándo se debe elegir NAnt sobre MSBuild? ¿Cuál es mejor para qué? ¿NAnt es más adecuado para proyectos domésticos / de código abierto y MSBuild para proyectos de trabajo? ¿Cuál es la experiencia con alguno de los dos?

Yordan Pavlov
fuente

Respuestas:

97

He hecho una investigación similar esta semana. Esto es lo que he podido determinar:

NAnt:

  • Multiplataforma (compatible con Linux / Mono). Puede ser útil para instalar un sitio web en múltiples destinos (es decir, Linux Apache y Windows IIS), por ejemplo.
  • 95% similar en sintaxis a Ant (fácil de usar para los usuarios actuales de Ant o los creadores de Java)
  • Integración con NUnit para ejecutar pruebas unitarias como parte de la compilación, y con NDoc para documentar la producción.

MSBuild:

  • Incorporado a .NET.
  • Integrado con Visual Studio
  • Fácil de comenzar con MSBuild en Visual Studio: todo está detrás de escena. Si desea profundizar, puede editar manualmente los archivos.

Diferencias subjetivas: (YMMV)

  • La documentación de NAnt es un poco más sencilla. Por ejemplo, la Referencia de tareas de MSBuild enumera "Tarea Csc - Describe la tarea Csc y sus parámetros" (gracias por la "ayuda"?), Frente a la Referencia de tareas NAnt "csc - Compila programas C #". ACTUALIZACIÓN: He notado que la documentación de MSBuild ha sido mejorada y ahora es mucho mejor (probablemente a la par con NAnt).
  • No es fácil descubrir cómo editar la fuente del script de compilación (*. * Archivo de proyecto) directamente desde Visual Studio. Con NAnt solo hago que Visual Studio trate el script .build como un archivo XML.
  • Aparentemente, en Visual Studio, los proyectos de aplicaciones web no obtienen un archivo de proyecto *. * De manera predeterminada, por lo que tuve grandes dificultades para descubrir cómo hacer que MSBuild se ejecute en el mío para crear un script de implementación.
  • NAnt no está integrado en Visual Studio y debe agregarse, ya sea con un complemento o como una "herramienta externa". Esto es un poco difícil de configurar.
  • (Editar :) Uno de mis compañeros de trabajo trajo esto a colación: si desea configurar una máquina de construcción utilizando CruiseControl para una integración continua, CruiseControl se integra con NAnt de forma inmediata. ACTUALIZACIÓN: CruiseControl también tiene una tarea MSBuild .
  • Vea los comentarios a continuación para una discusión completa y actualizada de las diferencias subjetivas.
Salmo de ogro33
fuente
puede editar un archivo .proj pero después de descargar el proyecto (debe haber una opción "Descargar" en el menú contextual del proyecto)
Yordan Pavlov
18
@Yordan: o simplemente ponga sus personalizaciones en un archivo .build separado (o lo que sea) e importe + ejecute eso desde su archivo .csproj. Entonces solo tiene que editar el .csproj una vez, y puede agregar el archivo .build a su solución. Haga doble clic y está editando como cualquier otro archivo. Puede asignar archivos .build al editor XML en sus opciones.
Kent Boogaart
9
Existe una tarea de MSBuild CCNet. Los detalles se pueden encontrar en: confluence.public.thoughtworks.org/display/CCNET/MsBuild+Task
Gavin Miller el
2
Vale la pena señalar que no necesita modificar los archivos .csproj. Puede usar un archivo MyProject.csproj.user para hacer esas modificaciones, dejando su archivo .csproj limpio y prístino. MSBuild sabe buscar esos archivos .user y los importará al proceso de compilación automáticamente. Ver: ahmed0192.blogspot.com/2006/11/…
CleverPatrick
3
@CleverHuman, ¿ese archivo .user generalmente no contiene modificaciones específicas del usuario para el proyecto que normalmente no registraría junto con el resto del proyecto? He usado la sugerencia de Kent durante años y funciona muy bien. Modifica el archivo PROJ una vez para incluir un segundo archivo PROJ, luego agrega el segundo archivo PROJ a tu proyecto. A partir de ese momento, puede personalizar fácilmente ese segundo archivo PROJ sin tener que pasar por el proceso de descarga / recarga. Tiendo a inclinarme hacia MSBuild solo por esta razón.
DarinH
77

Uno de los principales atractivos de MSBuild para mí (en plataformas Windows) es que viene como parte de .NET. Eso significa que cualquier máquina con Windows que esté actualizada con Windows Update tendrá MSBuild disponible. Agregue a esto el hecho de que el compilador de C # también es parte de .NET y tiene una plataforma que puede construir proyectos en máquinas limpias. No es necesario instalar Visual Studio behemoth. NAnt, por otro lado, debe instalarse explícitamente antes de que se pueda activar una compilación.

Solo para el registro, he usado NMake, Make, Ant, Rake, NAnt y MSBuild en compilaciones no triviales en el pasado (en ese orden). Mi favorito es MSBuild, sin dudas (y no lo favorezco porque "eso es lo que usa Visual Studio"). En mi humilde opinión, es una herramienta de construcción muy poco apreciada.

Yo compararía NAnt vs. MSBuild con la diferencia entre programación funcional y de procedimiento. NAnt es bastante sencillo y obtienes lo que ves. MSBuild por otro lado requiere un poco más de reflexión. La curva de aprendizaje es más pronunciada. Pero una vez que "lo entiendes", puedes hacer algunas cosas increíbles con él.

Por lo tanto, recomendaría mirar MSBuild si también gravita hacia una programación de estilo funcional o lógico, si está dispuesto a invertir un poco de tiempo y esfuerzo antes de ver resultados tangibles (por supuesto, también creo firmemente que la inversión finalmente vale la pena y usted puede hacer cosas más poderosas de manera más eficiente).

Milan Gardian
fuente
11
¡Guauu! No sabía que MSBuild venía con el tiempo de ejecución. Eso es genial y definitivamente puedo ver beneficios allí. Sin embargo, no entiendo la comparación entre funcional / procesal. Sería interesante saber qué hace que MSBuild sea mucho más poderoso una vez que uno "lo entiende".
Scott Saad el
2
Msbuild en realidad tiene una serie de dependencias en los archivos de varios sdks que solo se hacen evidentes durante la invocación de ciertos objetivos. Entonces, aunque msbuild está disponible de fábrica, es posible que no se ejecute.
Sam Shiles
66
Una cosa que debe agregarse: no solo es posible llamar a ensamblados .NET desde msbuild, lo que le da acceso a una gran cantidad de funciones muy útiles (por ejemplo, todo en Systme.IO.Path puede ser útil en los scripts de compilación) , también es posible escribir código C # simple en archivos msbuild y ejecutarlo. Lo cual es simplemente impresionante. msdn.microsoft.com/en-us/library/dd722601.aspx Y si las cosas se complican demasiado, escribir tareas personalizadas también es muy sencillo.
stijn
1
De Wikipedia: " MSBuild se incluyó previamente con .NET Framework; a partir de Visual Studio 2013, sin embargo, se incluye con Visual Studio".
DavidRR
MSBuild (Microsoft Build Tools 2013) también se puede descargar independientemente de Visual Studio 2013 aquí .
DavidRR
45

Personalmente, uso ambos, para el mismo proyecto.

MSBuild es excelente para crear soluciones y proyectos de Visual Studio, para eso está hecho.

NAnt es más fácil de editar a mano, en mi opinión, especialmente si ya conoces a Ant. NAnt puede llamar a MSBuild muy fácilmente con NAntContrib. Por lo tanto, creo a mano un script NAnt para hacer cosas como copiar archivos construidos, limpiar, etc., y llamar a MSBuild para hacer la parte real de "convertir mi código fuente C # en ensamblajes".

Si quieres un ejemplo de eso, mira mi archivo de compilación de Protocol Buffers . (No diría que es un fabuloso script de NAnt, pero hace el trabajo).

Jon Skeet
fuente
1
Y es compatible con Mono. El soporte MSBuild de Mono es horrible.
Mehrdad Afshari
@Mehrdad: Sí, en algún momento realmente debo intentar que los Buffers de protocolo se compilen en Mono ... actualmente hay un error de gmcs que impide que funcione :( Sin embargo, la idea siempre fue que eventualmente funcionaría en Mono.
Jon Skeet
1
Chicos, mono usa XBuild y es fácil portar MSBuild a XBuild. Mira esto: mono-project.com/Porting_MSBuild_Projects_To_XBuild .
fyasar
20

NAnt tiene más funciones listas para usar , pero MSBuild tiene una estructura fundamental mucho mejor (rocas de metadatos de elementos) que hace que sea mucho más fácil construir scripts de MSBuild reutilizables.

MSBuild tarda un tiempo en comprenderlo, pero una vez que lo hace, es muy agradable.

Aprendiendo materiales:

Konstantin Tarkus
fuente
38
Hey, he oído de esos libros :)
Sayed Ibrahim Hashimi
19

BESO = Usar MSBuild.

¿Por qué agregar algo más a la mezcla cuando tienes algo que hará un trabajo razonable fuera de la caja? Cuando llegó MSBuild, NAnt murió. Y Mono tendrá una implementación de MSBuild, ( xbuild ).

DRY = Usar MSBuild.

Pregúntese qué quiere de un sistema de compilación. Quiero un sistema de compilación que también use mi IDE en lugar de mantener dos configuraciones diferentes.

Personalmente, me encantaría escuchar algunos argumentos reales para NAnt, porque no puedo pensar en ninguno que realmente aguante.

Ardilla
fuente
2
"Cuando surgió msbuild, nant murió". Creo que este es el factor decisivo, incluso sin VS (que no uso).
harpo
Estoy de acuerdo. DotNet 1.1 no tenía msbuild.exe. Entonces nos jodieron en aquel entonces. Desde 2.0, msbuild.exe y las bibliotecas adicionales hacen mucho. Y escribir un MsBuild-Task personalizado tiene una curva de aprendizaje, pero he escrito unos 10 de ellos a lo largo de los años.
granadaCoder
1
Tengo que estar de acuerdo, debe usar la misma herramienta para compilar como desarrollador que usará el servidor de compilación, lo que le permite fallar más rápido.
krystan honor
14

Una cosa que noté que mencionan varios carteles fue tener que editar manualmente los archivos .csproj (o .vbproj, etc.).

MSBuild permite la personalización de estos archivos. * Proj mediante el uso de archivos .user. Si tengo un proyecto llamado MyCreativelyNamedProject.csproj y quiero personalizar las tareas de MSBuild dentro de él, puedo crear un archivo llamado MyCreativelyNamedProject.csproj.user y usar CustomBeforeMicrosoftCommonTargets y CustomAfterMicrosoftCommonTargets para personalizar esos archivos.

Además, tanto NAnt como MSBuild se pueden personalizar al contenido del corazón a través de tareas personalizadas de MSBuild y mediante extensiones de NantContrib.

Entonces, usar NAnt o MSBuild realmente se reduce a la familiaridad:

  • Si ya está familiarizado con Ant, use NAnt. La curva de aprendizaje será muy fácil.
  • Si no está familiarizado con ninguna de las herramientas, MSBuild ya está integrado con Visual Studio y no requiere herramientas adicionales.

También vale la pena agregar que MSBuild está prácticamente garantizado para trabajar con todas las versiones nuevas de .NET y Visual Studio tan pronto como se publiquen, mientras que NAnt puede tener algún retraso.

CleverPatrick
fuente
1
+1 para señalar el retraso entre las versiones .net y las versiones nant. Recuerdo cuando salió .net 3.5 y tuve que usar un nant.exe.config pirateado de las redes para que todo funcione. No es divertido.
mmacaulay
9
De acuerdo con muchas publicaciones por aquí, esos archivos .USER contienen + información específica del usuario + que no deberían registrarse, por lo que ese sería el último lugar donde me gustaría poner personalizaciones de compilación ... Cualquier personalización de compilación por definición no debería no sea específico del usuario, por lo que no debería ir en esos archivos .user ...
DarinH
1
De acuerdo con la aventura; .user-files son como el nombre sugiere al usuario pr y ni siquiera deberían registrarse en su repositorio de control de código fuente. Este NO es el lugar para automatizar la construcción.
Kjetil Klaussen
10

Utilizo ambos en que mis scripts NAnt llaman a MSBuild. Mi razón principal para quedarme con NAnt es el aislamiento . Déjame explicarte por qué siento que esto es importante:

  1. Agregar dependencias a su proyecto. El archivo de compilación NAnt es ajeno a Visual Studio (en mi caso lo considero un profesional), por lo que Visual Studio no intenta hacer nada con él. Las tareas de MSBuild están integradas, por lo que son parte de la solución y pueden referirse a otras tareas de MSBuild. Recibí el código fuente de otra persona solo para descubrir que no podía compilar, porque las tareas de la comunidad MSBuild no estaban instaladas. Lo que encuentro particularmente frustrante es que Visual Studio simplemente no se construyó y arrojó un montón de errores que me hicieron perder tiempo depurando. Esto, a pesar del hecho de que la compilación solicitada podría haber seguido adelante (como una compilación de depuración, por ejemplo) sin algunos de los extras de la tarea MSBuild. En resumen: no me gusta agregar dependencias a mi proyecto si puedo evitarlo .

  2. No confío en Visual Studio por lo que pude lanzar a su equipo de desarrollo. Esto se remonta a los primeros días de Visual Studio cuando masacraría mi HTML. Todavía no uso el diseñador, por ejemplo (en una conferencia recientemente encontré que mis colegas hicieron lo mismo). He descubierto que Visual Studio puede arruinar las dependencias y los números de versión en el archivo DLL (no puedo replicar esto, pero sucedió en un proyecto de manera consistente y causó mucho dolor y tiempo perdido). He recurrido a un procedimiento de compilación que usa Visual Studio para compilar solo en modo de depuración. Para la producción, uso NAnt para controlar todo externamente . Visual Studio simplemente no puede interferir más si construyo usando NAnt.

PD: Soy desarrollador web y no desarrollo Windows Forms.

Peter Mortensen
fuente
6

Si bien no estoy muy familiarizado con MsBuild, tengo la impresión de que algunas de las diferencias clave en ambos lados se pueden complementar con adiciones:

Recientemente tuve que construir un proyecto Silverlight en Nant. Descubrí que la vida sería más fácil si solo hiciera esto con MsBuild: terminé llamando a una tarea de MsBuild desde un script Nant, así que supongo que no es demasiado común mezclar y combinar los dos.

Más allá de eso, supongo que será una cuestión de preferencia personal: obviamente, puede administrar algunas / la mayoría de las funciones de MsBuild desde Visual Studio, si eso es lo que le gusta. Nant parece más flexible y más adecuado si prefieres escribir scripts a mano, y si vienes del mundo Java es probable que estés en casa con él.

mmacaulay
fuente
Buen punto. Ambas soluciones se pueden ampliar y personalizar fácilmente de la forma deseada.
CleverPatrick
2

Terminé usando ambos. Al rediseñar nuestro sistema de compilación, me enfrentaba a un problema complicado. Es decir, no podía deshacerme de .vcproj (y familia) porque todos estábamos usando VS para actualizar los archivos, configuraciones y configuraciones del proyecto. Entonces, sin un gran proceso de duplicación y propensión a errores, no podríamos basar nuestro sistema de compilación en un nuevo conjunto de archivos.

Por esta razón, decidí mantener los archivos 'proj' de VS y usar MSBuild (son archivos MSBuild, al menos VS2005 y VS2008 usan archivos de proyecto MSBuild). Para todo lo demás (configuración personalizada, pruebas unitarias, empaquetado, preparación de documentación ...) utilicé NAnt.

Para una integración continua, utilicé CruiseControl. Así que teníamos scripts CC que activaban trabajos de NAnt, que para la construcción usaban MSBuild.

Una nota final: ¡MSBuild NO admite proyectos de instalación! Así que estás atrapado en llamar a DevEnv.com o usar Visual Studio directamente. Eso es lo que terminé haciendo, pero desactivé el proyecto de configuración de forma predeterminada en todas las configuraciones de soluciones, ya que los desarrolladores normalmente no necesitarían compilarlas, y si lo hacen, pueden seleccionar manualmente para compilarlas.

Ceniza
fuente
1

La documentación y los tutoriales disponibles para NAnt hacen que sea más fácil comenzar a aprender scripts de compilación con NAnt. Una vez que aprendí NAnt y creé scripts de compilación, comencé a traducir ese conocimiento a MSBuild (hice X en NAnt, ¿cómo hago X en MSBuild?). La documentación de Microsoft generalmente supone un nivel bastante alto de conocimiento antes de que sea útil.

La razón para cambiar de NAnt a MSBuild es porque MSBuild es más actual. Lamentablemente, la última versión de NAnt fue el 8 de diciembre de 2007, mientras que MSBuild 4.0 (.NET 4.0) no está lejos. Parece que el proyecto NAnt ha muerto.

Si encuentra buena documentación para alguien que recién comienza a aprender a crear scripts de compilación utilizando MSBuild, omita NAnt y vaya directamente a MSBuild. Si NAnt alguna vez sale con un nuevo lanzamiento, entonces consideraría seguir con NAnt, pero ahora están rezagados.

Mcdon
fuente
1
A partir de junio de 2012, la versión 0.92 de NAnt está disponible en el sitio web: nant.sourceforge.net Y es compatible con .Net 4.0.
Brett Rigby
0

Usamos ambos NAnt es responsable de todas las cosas de "secuencias de comandos", como copiar, implementar en IIS , crear paquetes y MSBuild es responsable de crear la solución. Entonces podemos evitar problemas con .NET 4.0 no compatible con una nueva versión de NAnt.

NAnt también es más escalable. Si queremos migrar los scripts de implementación a los servidores de producción, solo copiamos el archivo de compilación e instalamos una versión adecuada de .NET, sin problemas de Visual Studio con archivos csproj :)

Leszek Wachowicz
fuente
0

YDeliver by Manoj es un marco de compilación construido sobre PSake. Tiene un amplio conjunto de funciones de biblioteca, capacidad para definir flujos de trabajo, y lo hemos utilizado para entregar más de seis proyectos empresariales a producción.

Úselo junto con TeamCity , CruiseControl o cualquier cosa que pueda ejecutar PowerShell .

Zasz
fuente
0

Usamos FlubuCore. Es una biblioteca C # de código abierto para construir proyectos y ejecutar scripts de implementación utilizando el código C #.

Ejemplo simple de cómo se usa flubu:

protected override void ConfigureTargets(ITaskContext session)
{           

    var compile = session.CreateTarget("compile")
        .SetDescription("Compiles the solution.")
        .AddTask(x => x.CompileSolutionTask())
        .DependsOn("generate.commonassinfo");
}

Puede encontrar más información sobre flubu y cómo comenzar aquí: choice-for-build-tool-msbuild-nant-or-something-else

Stan88
fuente