visual studio proyecto otro objeto net formulario form duplicar copiar control clonar .net build-process nant

.net - studio - duplicar un formulario en vb net



Mejor herramienta de compilación.NET (14)

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

¿Cuál es la mejor herramienta de compilación para .NET ?

Actualmente uso NAnt pero solo porque tengo experiencia con Ant . ¿Se prefiere MSBuild ?

En realidad usamos una combinación de NAnt y MSBuild con CruiseControl . NAnt se utiliza para el control de flujo de scripts y llama a MSBuild para compilar proyectos. Una vez que se desencadena la compilación física, NAnt se utiliza para publicar los resultados de compilación de proyectos individuales en una ubicación compartida.

No estoy seguro de que este sea el mejor proceso. Creo que muchos de nosotros todavía estamos buscando una gran herramienta de compilación. Una cosa prometedora que escuché recientemente en .NET Rocks, episodio 362 , es PSake de James Kovac , un sistema de compilación que se basa completamente en PowerShell. Parece realmente prometedor, ya que lo que se puede hacer con PowerShell es bastante ilimitado en teoría.

En términos generales, tengo la impresión de que NAnt ofrece más flexibilidad en comparación con MSBuild, mientras que (con mis necesidades relativamente simples) he estado bien con el último hasta ahora.

Estamos utilizando Bounce , un framework para scripts de construcción más limpios en C #.

Hay otra nueva herramienta de compilación (una envoltura muy inteligente) llamada NUBuild . Es liviano, de código abierto y extremadamente fácil de configurar y proporciona un mantenimiento casi sin contacto. Realmente me gusta esta nueva herramienta, y la hemos convertido en una herramienta estándar para nuestra construcción e integración continua de nuestros proyectos (tenemos alrededor de 400 proyectos en 75 desarrolladores). Pruébalo.

http://nubuild.codeplex.com/

  • Interfaz de línea de comando fácil de usar
  • Posibilidad de orientar todas las versiones de .NET Framework, es decir, 1.1, 2.0, 3.0 y 3.5
  • Admite configuración basada en XML
  • Admite referencias de proyectos y archivos
  • Genera automáticamente la "lista completa de compilación ordenada" para un proyecto determinado - Sin mantenimiento táctil.
  • Capacidad de detectar y mostrar dependencias circulares
  • Realizar creación paralela: decide automáticamente cuál de los proyectos en la lista de compilación generada se puede generar de forma independiente.
  • Capacidad de manejar ensambles proxy
  • Proporciona una pista visual del proceso de compilación, por ejemplo, que muestra "% completado", "estado actual", etc.
  • Genera un registro de ejecución detallado tanto en formato XML como en formato de texto
  • Fácilmente integrado con el sistema de integración continua CruiseControl.NET
  • Puede usar un registrador personalizado como XMLLogger cuando se orienta a la versión 2.0 +
  • Posibilidad de analizar los registros de errores
  • Posibilidad de implementar conjuntos construidos en la ubicación especificada por el usuario
  • Posibilidad de sincronizar el código fuente con el sistema de control de fuente
  • Capacidad de gestión de versiones

He usado MSBuild y NAnt, y prefiero MSBuild, principalmente porque requiere mucha menos configuración por defecto. Aunque puede complicar demasiado las cosas y cargar MSBuild con una gran cantidad de basura de configuración también, en su forma más simple, puede apuntarla a un archivo de solución / proyecto y hacer que funcione, la mayoría de las veces, para la mayoría de los casos, es suficiente.

He usado ambos y prefiero NAnt . Es realmente difícil para mí decir que uno es "mejor" que el otro.

Me gustaría lanzar FinalBuilder a la mezcla. No es gratis, pero si estás harto de editar archivos XML y quieres un entorno más agradable ( IMO ) para trabajar, lo probaría.

He trabajado con todos ellos y siempre volví a FinalBuilder.

También depende de lo que estás construyendo. La biblioteca MSBuild SDC Task tiene un par de tareas especiales. Por ejemplo, para AD , BizTalk , etc.

Hay más de 300 tareas incluidas en esta biblioteca, incluidas tareas para: crear sitios web, crear grupos de aplicaciones, crear usuarios de ActiveDirectory, ejecutar FxCop , configurar servidores virtuales, crear archivos zip, configurar COM + , crear carpetas compartidas, instalar en el GAC , configurar SQL Server , configurando BizTalk 2004 y BizTalk 2006, etc.

UppercuT usa NAnt para construir y es el Framework de construcción terriblemente fácil de usar.

¡Las compilaciones automatizadas son tan sencillas como (1) nombre de la solución, (2) ruta de control de origen, (3) nombre de la empresa para la mayoría de los proyectos!

http://projectuppercut.org/

Algunas buenas explicaciones aquí: UppercuT

Usamos MSBuild, porque comenzamos con Visual Studio 2005 (ahora Visual Studio 2008) y MSBuild ya estaba "integrado" en el SDK, hay menos mantenimiento en el servidor de compilación. En realidad, es un clon de NAnt: ambas herramientas son infinitamente flexibles ya que le permiten crear tareas de creación personalizadas en código, y ambas tienen un conjunto decente de tareas de creación de comunidad ya creadas.

Usar un lenguaje de scripting dinámico como Python, BOO, Ruby, etc. para crear y mantener scripts de construcción puede ser una buena alternativa a uno basado en XML como NAnt. (Tienden a ser más limpios de leer que XML).

Yo uso MSBuild completamente para construir. Aquí está mi script MSBuild genérico que busca en el árbol los archivos .csproj y los construye:

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build"> <UsingTask AssemblyFile="$(MSBuildProjectDirectory)/bin/xUnit/xunitext.runner.msbuild.dll" TaskName="XunitExt.Runner.MSBuild.xunit"/> <PropertyGroup> <Configuration Condition="''$(Configuration)''==''''">Debug</Configuration> <DeployDir>$(MSBuildProjectDirectory)/Build/$(Configuration)</DeployDir> <ProjectMask>$(MSBuildProjectDirectory)/**/*.csproj</ProjectMask> <ProjectExcludeMask></ProjectExcludeMask> <TestAssembliesIncludeMask>$(DeployDir)/*.Test.dll</TestAssembliesIncludeMask> </PropertyGroup> <ItemGroup> <ProjectFiles Include="$(ProjectMask)" Exclude="$(ProjectExcludeMask)"/> </ItemGroup> <Target Name="Build" DependsOnTargets="__Compile;__Deploy;__Test"/> <Target Name="Clean"> <MSBuild Projects="@(ProjectFiles)" Targets="Clean"/> <RemoveDir Directories="$(DeployDir)"/> </Target> <Target Name="Rebuild" DependsOnTargets="Clean;Build"/> <!-- ===== Targets that are meant for use only by MSBuild ===== --> <Target Name="__Compile"> <MSBuild Projects="@(ProjectFiles)" Targets="Build"> <Output TaskParameter="TargetOutputs" ItemName="AssembliesBuilt"/> </MSBuild> <CreateItem Include="@(AssembliesBuilt -> ''%(RootDir)%(Directory)*'')"> <Output TaskParameter="Include" ItemName="DeployFiles"/> </CreateItem> </Target> <Target Name="__Deploy"> <MakeDir Directories="$(DeployDir)"/> <Copy SourceFiles="@(DeployFiles)" DestinationFolder="$(DeployDir)"/> <CreateItem Include="$(TestAssembliesIncludeMask)"> <Output TaskParameter="Include" ItemName="TestAssemblies"/> </CreateItem> </Target> <Target Name="__Test"> <xunit Assembly="@(TestAssemblies)"/> </Target> </Project>

(Lo siento si es un poco denso. Markdown parece estar eliminando las líneas en blanco).

Sin embargo, es bastante simple una vez que entiendes los conceptos y todas las dependencias se manejan automáticamente. Debo señalar que usamos archivos de proyecto de Visual Studio, que tienen mucha lógica incorporada, pero este sistema permite a las personas crear casi idénticamente dentro del IDE de Visual Studio o en la línea de comandos y aún así le da la flexibilidad de agregar cosas a la construcción canónica como la prueba xUnit que ves en el script de arriba.

El único PropertyGroup es donde sucede toda la configuración y las cosas se pueden personalizar, como excluir ciertos proyectos de la compilación o agregar nuevas máscaras de ensamblaje de prueba.

El ItemGroup es donde ocurre la lógica que encuentra todos los archivos .csproj en el árbol.

Luego están los objetivos, que la mayoría de las personas que están familiarizadas con make, nAnt o MSBuild deberían ser capaces de seguir. Si llama al objetivo de compilación, llama a __Compile, __Deploy y __Test. El objetivo Limpio llama a MSBuild en todos los archivos de proyecto para que limpien sus directorios y luego se elimina el directorio de despliegue global. Reconstruye las llamadas Limpiar y luego compilar.