MSBuild: ¿usa el file .csproj o hace el suyo?

OK, así que concedo fácilmente que soy un novato en lo que respecta a la continuous integration.

Una vez dicho esto, estoy tratando de configurar un entorno CC.NET para educarme, pero tengo problemas para encontrar la información que necesito para configurar la parte de compilation automatizada.

Según lo entiendo, en C # el file .csproj producido por VS 2005 y reenviar es un file válido de MSBuild. A saber, he podido integrar la tarea MSBuild en CC.NET usando el file .csproj, pero tengo algunos problemas con esto:

  1. Están sucediendo muchas cosas aquí que no estoy seguro de que realmente necesite en un entorno de construcción automatizado.
  2. No creé este file. No lo entiendo, y eso me asusta. ( Progtwigción por coincidencia )
  3. La mayor parte de lo que está sucediendo parece $(MSBuildToolsPath)\Microsoft.CSharp.targets abstraído a través de $(MSBuildToolsPath)\Microsoft.CSharp.targets
  4. Como resultado de 1, 2 y 3, la modificación del file para include algo como MbUnit parece intrincado y más difícil de lo que debe ser. Mi única opción real es includelo en la sección AfterBuild , que parece algo así como un truco para mí.

Entonces, algunas preguntas para la gente de CC.NET, la gente de MSBuild y la gente de MbUnit.

  1. Al usar MSBuild, ¿es aconsejable usar el file .csproj generado por VS como el file de compilation? ¿O debería crear el mío?
  2. ¿Las testings de MbUnit deberían ser parte del file MSBuild o del file CC.NET? Mi investigación parece sugerir que pertenecen al file MSBuild. Si ese es el caso, ¿creo un nuevo file MSBuild .proj y lo compruebo en CVS además del file .csproj? ¿O la tarea MbUnit se convierte en parte de mi file .csproj?
  3. Similar a la pregunta 2. Si agrego las testings de MbUnit al file MSBuild y termino usando el file .csproj, ¿el Target Name="AfterBuild" realmente la sección para agregar esa información? ¿No debería haber una sección Target Name="Test" ? El uso del file .csproj generado por VS parece evitar la segunda opción.

Sé que hay muchas cosas allí, pero la mayoría de lo que he podido encontrar en línea asume un cierto nivel de familiaridad con estos temas que simplemente no tengo, a less que esté equivocado, la curva de aprendizaje para este tema no es No es una curva en absoluto, es una function de paso. 🙂

Edición 1: actualicé el text para ser un poco más conciso y para abordar algunas preguntas persistentes que he tenido con las respuestas.

Yo recomendaría usar los files .csproj generados, de hecho para producción, creo que usar los files .sln generados es una buena idea. Descubrí que ganarás utilizando los mismos files de solución que los desarrolladores.

Tenga en count que los files .sln no son realmente files de proyecto de msbuild válidos, sino que se transforman en proyectos msbuild por sí mismo cuando se usan como inputs. ¡Difícil!

Para fines de aprendizaje, es posible que desee registrar la compilation de un .csproj y dar un paso adelante para tener una idea de lo que está sucediendo. MSBuild es un poco más declarativo que nant, así que tómate tu time y experimenta un poco.

Finalmente, envolvería sus files .sln o .csproj en un proyecto de script de compilation continuo con tareas de msbuild para build sus proyectos y ejecutar sus testings unitarias. De esta manera, los desarrolladores no tienen que ejecutar la testing unitaria cada vez que comstackn, pero cada vez que integran su código se ejecutarán las testings unitarias. Y sí, ¡asegúrese de que corran rápido! Todo lo que tome más de un segundo se debe ejecutar durante una compilation progtwigda (¿nocturna?). Probablemente sean less testings unitarias y más testings de integración escritas con un marco de testing unitaria si tardan más de un segundo.

Editar: alguna información de adición que he encontrado que he encontrado útil, usar MSBuild 3.5 te permitirá get el resultado de un file .sln, mientras que esta información no se devuelve en MSBuild 2.0 (aunque creo que debería funcionar para .csproj files en ambas versiones). Puede usar la salida (sus files construidos) como inputs al marco de testing de su unidad.

Deje el file csproj bien solo (como dices, no lo entiendes).

Cree su propio file de proyecto msbuild y llame al csproj (o sln) desde su file de compilation principal a través de la tarea msbuild. Dile a tu server de CI que construya tu file de compilation.

Esta separación hace que sea más fácil agregar sus propias tareas previas y posteriores (testings unitarias, testings de humo de scripts SQL, fxcop / otro análisis estático, etc.) y no romperá su entorno de trabajo. También significa que puede hacer sus objectives personalizados en lo que desee (msbuild / ant, etc.). Mire como MSBuildContrib en codeplex para mayor bondad.

No necesita estar visualizado en su server de compilation (siempre que tenga proyectos de implementación, a less que esto también haya cambiado desde la última vez que lo busqué)

Cree su propio file de proyecto (todo lo que termine con * proj sea considerado un file de proyecto por MSBuild) y llame a su compilation desde allí. Me gusta esto:

 <MSBuild Projects="MySolution.sln" Targets="Clean; Rebuild" Properties="Configuration=$(BuildMode);"> 

Tenga en count que msbuild también puede comstackr .sln (file de solución) sin ningún cambio, que generalmente es más fácil que tener un montón de files csproj …

Yo uso NAnt y MSBuild. NAnt se actualizó con NAntContrib para que obtuviera las tomas de msbuild. Puedo ser una configuration temporal, pero hasta ahora no he tenido problemas importantes. Dicho esto, tampoco creo un nuevo file csproj porque utilizo el mismo csproj / sln que uso en VS2008. La construcción de proyectos con msbuild simplificó en gran medida las secuencias de commands de NAnt (utilizamos la tarea de csc ).

Notas:

  1. Si utiliza Windows Workflow Foundation en sus proyectos, tendrá grandes dificultades para build dicho proyecto sin msbuild.
  2. No instales VS.NET en tu máquina de compilation. Puede usar Wix do create installation msi.
  3. @Franci Penov: las testings de unidades en ejecución DEBERÍAN formar parte de cada construcción. ¿De verdad quieres esperar hasta mañana para encontrar un error? Hay una nota al margen: las testings unitarias deben ejecutarse muy rápido.

Personalmente creo que está bien ir con el file .csproj. No está sucediendo mucho allí que no tendría que agregarse a sí mismo si desarrolla su propio proyecto MSBuild.

Sin embargo, cualquiera que sea la ruta que decida utilizar, le recomiendo que no agregue el MbUnit como parte de su paso de compilation, sino que lo agregue como un paso separado en CC.Net. Las testings unitarias en ejecución deben ser parte del ciclo diario de IC; sin embargo, no debería ser parte de cada construcción.

OK, algunas cosas de las que hay que estar pendiente. El formatting csproj ha cambiado de VS2005 a VS2008. Además, si va con MSBuild, recuerde que no podrá build files .vdproj (setup); para eso necesitas devenv (el ejecutable VS). Dicho esto, siempre puedes crear una tarea MSBuild que invoque a devenv y la cree para ti.

En cuanto a su pregunta sobre si crear su propio file csproj o usar el creado por VS2005, sugeriría un path intermedio: cree su propia plantilla de proyecto , que atienda sus necesidades y deje que VS se encargue del rest.

Está bien usar .csproj como input para msbuild. Puede agregar tareas manualmente en csproj, que se ignorarán al realizar un pedido desde VS. Pero si va a hacer algunas cosas no triviales, es mejor crear scripts separados de msbuild. Y pueden ser referencedos desde files csproj. ¿Has echado un vistazo al MS Build Server que es parte de TFS? Se integra con SourceControl de TFS y podría usarse para CI. Sus files de proyecto son scripts de msbuild.

Si utilicé nAnt, ¿es necesario que VS esté instalado en el server? ¿Querías decir 'MSBuild'? No, no es necesariamente instalar VS para usar msbuild con files csproj.