Share via

Tutorial: Crear un archivo del proyecto de MSBuild desde el principio

  • Artículo

Los lenguajes de programación que tienen como destino .NET Framework, por ejemplo, Visual C# y Visual Basic, utilizan archivos del proyecto de MSBuild para describir y controlar el proceso de compilación de aplicaciones. Cuando se usa Visual Studio para crear un archivo del proyecto de MSBuild, el XML adecuado se agrega al archivo automáticamente. Sin embargo, puede ser de utilidad comprender cómo se organiza el XML y cómo se puede cambiar para controlar una compilación. Este tutorial muestra la forma de crear un archivo básico del proyecto de forma incremental, utilizando solo un editor de texto. El tutorial sigue estos pasos:

  • Crear un archivo de código fuente de aplicación mínima.

  • Crear un archivo del proyecto de MSBuild mínimo.

  • Extender la variable de entorno PATH para incluir MSBuild.

  • Compilar la aplicación utilizando el archivo del proyecto.

  • Agregar propiedades para controlar la compilación.

  • Controlar la compilación cambiando los valores de propiedad.

  • Agregar destinos a la compilación.

  • Controlar la compilación especificando destinos.

  • Compilar de forma incremental.

Este tutorial muestra la forma de compilar el proyecto en el símbolo del sistema y examinar los resultados. Para obtener más información sobre MSBuild y cómo se ejecuta MSBuild en el símbolo del sistema, vea Tutorial: Usar MSBuild.

Para completar el tutorial, debe tener instalado .NET Framework (versión 2.0, 3.5 ó 4) porque incluye MSBuild y el compilador de Visual C#, que se requieren para el tutorial.

Crear una aplicación mínima

En esta sección se muestra la forma de crear un archivo de código fuente de aplicación de Visual C# mínima utilizando un editor de texto.

Para crear la aplicación mínima

  1. En el símbolo del sistema, vaya a la carpeta donde desea crear la aplicación, por ejemplo, \My Documents\ o \Desktop\.

  2. Escriba md HelloWorld para crear una subcarpeta denominada \HelloWorld\.

  3. Escriba cd HelloWorld para cambiar a la nueva carpeta.

  4. Inicie el Bloc de notas u otro editor de texto y, a continuación, escriba el código siguiente.

    using System;

class HelloWorld
{
    static void Main()
    {
#if DebugConfig
        Console.WriteLine("WE ARE IN THE DEBUG CONFIGURATION");
#endif

        Console.WriteLine("Hello, world!");
    }
}

  5. Guarde este archivo de código fuente y denomínelo Helloworld.cs.

  6. Compile la aplicación escribiendo csc helloworld.cs en el símbolo del sistema.

  7. Pruebe la aplicación escribiendo helloworld en el símbolo del sistema.

    Se debe mostrar el mensaje Hello, world!

  8. Elimine la aplicación escribiendo del helloworld.exe en el símbolo del sistema.

Crear un archivo del proyecto de MSBuild mínimo

Ahora que tiene un archivo de código fuente de aplicación mínima, puede crear un archivo del proyecto mínimo para compilar la aplicación. Este archivo del proyecto contiene los elementos siguientes:

  • El nodo raíz Project necesario.

  • Un nodo ItemGroup para contener los elementos.

  • Un elemento que hace referencia al archivo de código fuente de aplicación.

  • Un nodo Target para contener las tareas necesarias para compilar la aplicación.

  • Un elemento Task para iniciar el compilador de Visual C# con el fin de compilar la aplicación.

Para crear un archivo del proyecto de MSBuild mínimo

  1. En el editor de texto, reemplace el texto existente utilizando estas dos líneas:

    <Project xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
</Project>

  2. Inserte este nodo ItemGroup como elemento secundario del nodo Project:

      <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>

    Observe que este ItemGroup ya contiene un elemento.

  3. Agregue un nodo Target como elemento secundario del nodo Project. Asigne al nodo el nombre Build.

      <Target Name="Build">
  </Target>

  4. Inserte este elemento de tarea como elemento secundario del nodo Target:

        <Csc Sources="@(Compile)"/>

  5. Guarde este archivo del proyecto y denomínelo Helloworld.csproj.

Su archivo del proyecto mínimo debe ser similar al código siguiente:

<Project xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
  <Target Name="Build">
    <Csc Sources="@(Compile)"/>  
  </Target>
</Project>

Las tareas en el destino Build se ejecutan secuencialmente. En este caso, la tarea Csc del compilador de Visual C# es la única tarea. Espera la compilación de una lista de archivos de código fuente y esto se produce mediante el valor del elemento Compile. El elemento Compile hace referencia a solo un archivo de código fuente, Helloworld.cs.

Nota

En el elemento, puede utilizar el carácter comodín asterisco (*) para hacer referencia a todos los archivos cuya extensión de nombre de archivo sea .cs, del modo siguiente:

<Compile Include="*.cs" />

Sin embargo, no se recomienda el uso de caracteres comodín porque dificulta la depuración y la asignación selectiva de destino si se agregan o eliminan archivos de código fuente.

Extender la ruta de acceso para incluir MSBuild

Antes de poder tener acceso a MSBuild, debe extender la variable de entorno PATH para incluir la carpeta .NET Framework.

Para extender la ruta de acceso para incluir MSBuild

  • En el símbolo del sistema, escriba set PATH=%PATH%;%WINDIR%\Microsoft.Net\Framework\v4.0. Si tiene instalada otra versión de .NET Framework, cambie el número de versión consecuentemente.

    Nota

    El nombre de la carpeta MSBuild en su equipo podría incluir un número de compilación como v2.0.50727. En ese caso, incluya el número de compilación en la línea de comandos, por ejemplo, set PATH=%PATH%;%WINDIR%\Microsoft.Net\Framework\v2.0.50727.

    Alternativamente, si tiene instalado Visual Studio, puede utilizar el símbolo del sistema de Visual Studio, que tiene una ruta de acceso que incluye la carpeta MSBuild.

Usar el archivo del proyecto para compilar la aplicación

Ahora, para compilar la aplicación, utilice el archivo del proyecto que acaba de crear.

Para compilar la aplicación

  1. En el símbolo del sistema, escriba msbuild helloworld.csproj /t:Build.

    Esto genera el destino Build del archivo del proyecto Helloworld al llamar al compilador de Visual C# para crear la aplicación Helloworld.

  2. Pruebe la aplicación escribiendo helloworld.

    Se debe mostrar el mensaje Hello, world!

Nota

Puede ver más detalles sobre la compilación aumentando el nivel de detalle. Para establecer el nivel de detalle en "detailed", escriba cualquiera de estos comandos en el símbolo del sistema:

msbuild helloworld.csproj /t:Build /verbosity:detailed

Agregar propiedades de compilación

Puede agregar propiedades de compilación al archivo del proyecto para controlar mejor la compilación. Agregue ahora estas propiedades:

  • Una propiedad AssemblyName para especificar el nombre de la aplicación.

  • Una propiedad OutputPath para especificar una carpeta que contenga la aplicación.

Para agregar propiedades de compilación

  1. Elimine la aplicación existente escribiendo del helloworld.exe en el símbolo del sistema.

  2. En el archivo del proyecto, inserte este elemento PropertyGroup justo después del elemento Project de apertura:

      <PropertyGroup>
    <AssemblyName>MSBuildSample</AssemblyName>
    <OutputPath>Bin\</OutputPath>
  </PropertyGroup>

  3. Agregue esta tarea al destino Build, justo antes de la tarea Csc:

        <MakeDir Directories="$(OutputPath)"      Condition="!Exists('$(OutputPath)')" />

    La tarea MakeDir crea una carpeta denominada por la propiedad OutputPath, con tal de que no exista actualmente ninguna carpeta con ese nombre.

  4. Agregue este atributo OutputAssembly a la tarea Csc.

    <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />

    Esto indica al compilador de Visual C# que cree un ensamblado denominado por la propiedad AssemblyName y lo coloque en la carpeta denominada por la propiedad OutputPath.

  5. Guarde los cambios.

Su archivo del proyecto debe ser ahora similar al código siguiente:

<Project xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <AssemblyName>MSBuildSample</AssemblyName>
    <OutputPath>Bin\</OutputPath>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
  <Target Name="Build">
    <MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
    <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
  </Target>
</Project>

Nota

Se recomienda agregar el delimitador de ruta de acceso barra diagonal inversa (\) al final del nombre de la carpeta al especificarlo en el elemento OutputPath, en lugar de agregarlo en el atributo OutputAssembly de la tarea Csc. Por lo tanto,

<OutputPath>Bin\</OutputPath>

OutputAssembly=="$(OutputPath)$(AssemblyName).exe" />

es mejor que

<OutputPath>Bin</OutputPath>

OutputAssembly=="$(OutputPath)\$(AssemblyName).exe" />

Probar las propiedades de compilación

Ahora puede compilar la aplicación utilizando el archivo del proyecto en el que utilizó propiedades de compilación para especificar la carpeta de salida y el nombre de aplicación.

Para probar las propiedades de compilación

  1. En el símbolo del sistema, escriba msbuild helloworld.csproj /t:Build.

    De este modo se crea la carpeta \Bin\ y, a continuación, se llama al compilador de Visual C# para crear la aplicación MSBuildSample y colocarla en dicha carpeta.

  2. Para comprobar que se ha creado la carpeta \Bin\ y que contiene la aplicación MSBuildSample, escriba dir Bin.

  3. Pruebe la aplicación escribiendo Bin\MSBuildSample.

    Se debe mostrar el mensaje Hello, world!

Agregar destinos de compilación

A continuación, agregue dos destinos más al archivo del proyecto, del siguiente modo:

  • Un destino Clean que elimine los archivos antiguos.

  • Un destino Rebuild que utilice el atributo DependsOnTargets para obligar a que la tarea Clean se ejecute antes que la tarea Build.

Ahora que tiene varios destinos, puede establecer el destino Build como destino predeterminado.

Para agregar destinos de compilación

  1. En el archivo del proyecto, agregue estos dos destinos justo después del destino Build:

      <Target Name="Clean" >
    <Delete Files="$(OutputPath)$(AssemblyName).exe" />
  </Target>
  <Target Name="Rebuild" DependsOnTargets="Clean;Build" />

    El destino Clean llama a la tarea Delete para eliminar la aplicación. El destino Rebuild no se ejecutará hasta que se hayan ejecutado el destino Clean y el destino Build. Aunque el destino Rebuild no tiene tareas, hace que el destino Clean se ejecute antes que el destino Build.

  2. Agregue este atributo DefaultTargets al elemento Project.

    <Project DefaultTargets="Build" xmlns="https://schemas.microsoft.com/developer/msbuild/2003">

    Esto establece el destino Build como destino predeterminado.

Su archivo del proyecto debe ser ahora similar al código siguiente:

<Project DefaultTargets="Build" xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <AssemblyName>MSBuildSample</AssemblyName>
    <OutputPath>Bin\</OutputPath>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
  <Target Name="Build">
    <MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
    <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
  </Target>
  <Target Name="Clean" >
    <Delete Files="$(OutputPath)$(AssemblyName).exe" />
  </Target>
  <Target Name="Rebuild" DependsOnTargets="Clean;Build" />
</Project>

Probar los destinos de compilación

Puede utilizar los nuevos destinos de compilación para probar estas características del archivo del proyecto:

  • Compilar la compilación predeterminada.

  • Establecer el nombre de aplicación en el símbolo del sistema.

  • Eliminar la aplicación antes de que se compile otra aplicación.

  • Eliminar la aplicación sin que se compile otra aplicación.

Para probar los destinos de compilación

  1. En el símbolo del sistema, escriba msbuild helloworld.csproj /p:AssemblyName=Greetings.

    Como no utilizó el modificador /t para establecer el destino explícitamente, MSBuild ejecutará el destino Build predeterminado. El modificador /p invalida la propiedad AssemblyName y le da el nuevo valor, Greetings. Esto hace que se cree una nueva aplicación, Greetings.exe, en la carpeta \Bin\.

  2. Para comprobar que la carpeta \Bin\ contiene la aplicación MSBuildSample y la nueva aplicación Greetings, escriba dir Bin.

  3. Pruebe la aplicación Greetings escribiendo Bin\Greetings.

    Se debe mostrar el mensaje Hello, world!

  4. Elimine la aplicación MSBuildSample escribiendo msbuild helloworld.csproj /t:clean.

    Esto ejecuta la tarea Clean para quitar la aplicación que tiene el valor de propiedad AssemblyName predeterminado, MSBuildSample.

  5. Elimine la aplicación Greetings escribiendo msbuild helloworld.csproj /t:clean /p:AssemblyName=Greetings.

    Esto ejecuta la tarea Clean para quitar la aplicación que tiene el valor de propiedad AssemblyName dado, Greetings.

  6. Para comprobar que la carpeta \Bin\ está ahora vacía, escriba dir Bin.

  7. Escriba msbuild.

    Aunque no se especifica un archivo del proyecto, MSBuild crea el archivo helloworld.csproj porque solo hay un archivo del proyecto en la carpeta actual. Esto hace que se cree la aplicación MSBuildSample en la carpeta \Bin\.

    Para comprobar que la carpeta \Bin\ contiene la aplicación MSBuildSample, escriba dir Bin.

Compilar de forma incremental

Puede indicar a MSBuild que cree un destino sólo si los archivos de código fuente o los archivos de destino de los que depende el destino han cambiado. MSBuild utiliza la marca de tiempo de un archivo para determinar si ha cambiado.

Para compilar de forma incremental

  1. En el archivo del proyecto, agregue estos atributos al destino Build de apertura:

    Inputs="@(Compile)" Outputs="$(OutputPath)$(AssemblyName).exe"

    Esto especifica que el destino Build depende de los archivos de entrada que se especifican en el grupo de elementos Compile y que el destino de salida es el archivo de aplicación.

    El destino Build resultante debe ser similar al código siguiente:

    <Target Name="Build" Inputs="@(Compile)" Outputs="$(OutputPath)$(AssemblyName).exe">
  <MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
  <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
</Target>

  2. Pruebe el destino Build escribiendo msbuild /v:d en el símbolo del sistema.

    Recuerde que helloworld.csproj es el archivo del proyecto predeterminado y que Build es el destino predeterminado.

    El modificador /v:d especifica una descripción detallada del proceso de compilación.

    Se deben mostrar estas líneas:

    Skipping target "Build" because all output files are up-to-date with respect to the input files.

    Input files: HelloWorld.cs

    Output files: Bin\MSBuildSample.exe

    MSBuild omite el destino Build porque ninguno de los archivos de código fuente ha cambiado desde que la aplicación se compiló por última vez.

Ejemplo

Descripción

En el ejemplo siguiente se muestra un archivo del proyecto que compila una aplicación de Visual C# y registra un mensaje que contiene el nombre del archivo de salida.

Código

<Project DefaultTargets = "Compile"
    xmlns="https://schemas.microsoft.com/developer/msbuild/2003" >

    <!-- Set the application name as a property -->
    <PropertyGroup>
        <appname>HelloWorldCS</appname>
    </PropertyGroup>

    <!-- Specify the inputs by type and file name -->
    <ItemGroup>
        <CSFile Include = "consolehwcs1.cs"/>
    </ItemGroup>

    <Target Name = "Compile">
        <!-- Run the Visual C# compilation using input files of type CSFile -->
        <CSC
            Sources = "@(CSFile)"
            OutputAssembly = "$(appname).exe">
            <!-- Set the OutputAssembly attribute of the CSC task
            to the name of the executable file that is created -->
            <Output
                TaskParameter = "OutputAssembly"
                ItemName = "EXEFile" />
        </CSC>
        <!-- Log the file name of the output file -->
        <Message Text="The output file is @(EXEFile)"/>
    </Target>
</Project>

Ejemplo

Descripción

En el ejemplo siguiente se muestra un archivo del proyecto que compila una aplicación de Visual Basic y registra un mensaje que contiene el nombre del archivo de salida.

Código

<Project DefaultTargets = "Compile"
    xmlns="https://schemas.microsoft.com/developer/msbuild/2003" >

    <!-- Set the application name as a property -->
    <PropertyGroup>
        <appname>HelloWorldVB</appname>
    </PropertyGroup>

    <!-- Specify the inputs by type and file name -->
    <ItemGroup>
        <VBFile Include = "consolehwvb1.vb"/>
    </ItemGroup>

    <Target Name = "Compile">    
        <!-- Run the Visual Basic compilation using input files of type VBFile -->
        <VBC
            Sources = "@(VBFile)"
            OutputAssembly= "$(appname).exe">
            <!-- Set the OutputAssembly attribute of the VBC task
            to the name of the executable file that is created -->
            <Output
                TaskParameter = "OutputAssembly"
                ItemName = "EXEFile" />
        </VBC>
        <!-- Log the file name of the output file -->
        <Message Text="The output file is @(EXEFile)"/>
    </Target>
</Project>

Pasos adicionales

Visual Studio puede realizar automáticamente gran parte del trabajo que se muestra en este tutorial. Para obtener información sobre cómo utilizar Visual Studio para crear, editar, compilar y probar archivos del proyecto de MSBuild, vea Tutorial: Usar MSBuild.

Vea también

Otros recursos

MSBuild

Referencia de MSBuild