Compartilhar via

Walkthrough: Criando um Arquivo de projeto MSBuild a partir do zero

  • Artigo

Destino de linguagens de programação do.NET Framework, por exemplo, Visual C# e Visual Basic, use os arquivos de projeto MSBuild para descrever e controlar o processo de compilação do aplicativo. Quando você usa Visual Studio para criar um arquivo de projeto MSBuild, o XML adequado é adicionado automaticamente ao arquivo. No entanto, talvez você ache útil compreender como o XML é organizado e como alterá-lo para controlar uma compilação. Esta explicação passo a passo mostra como criar um arquivo de projeto básico de forma incremental, usando um editor de texto. Explicação segue estas etapas:

  • Crie um arquivo de origem de aplicativo mínimo.

  • Crie um arquivo de projeto MSBuild mínimo.

  • Estenda a variável de ambiente PATH para incluir o MSBuild.

  • Crie o aplicativo usando o arquivo de projeto.

  • Adicione propriedades para controlar a compilação.

  • Controle a compilação, alterando os valores de propriedade.

  • Adicione destinos para a compilação.

  • Controle a compilação, especificando os destinos.

  • Compilação incremental.

Esta explicação passo a passo mostra como construir o projeto no prompt de comando e examine os resultados. Para obter mais informações sobre o MSBuild e como executar o MSBuild no prompt de comando, consulte Walkthrough: Usando o MSBuild.

Para concluir o passo a passo, você deve ter o.NET Framework (versão 2.0, 3.5 ou 4.0) instalado porque ele inclui o MSBuild e o compilador do Visual C#, são necessários para o passo a passo.

Criando um aplicativo mínimo

Esta seção mostra como criar um mínimo Visual C# aplicativo arquivo de origem usando um texto no editor.

Para criar o aplicativo mínimo

  1. No prompt de comando, navegue até a pasta onde você deseja criar o aplicativo, por exemplo, \My Documents\ ou \Desktop\.

  2. Tipo de md HelloWorld para criar uma subpasta denominada \HelloWorld\.

  3. Tipo de cd HelloWorld para alterar para a nova pasta.

  4. Inicie o bloco de notas ou outro editor de texto e, em seguida, digite o seguinte código.

    using System;

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

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

  5. Salvar este arquivo de código-fonte e o nome de Helloworld.cs.

  6. Construir o aplicativo digitando csc helloworld.cs no prompt de comando.

  7. Testar o aplicativo digitando helloworld no prompt de comando.

    O Hello, world! mensagem deve ser exibida.

  8. Excluir o aplicativo digitando del helloworld.exe no prompt de comando.

Criando um arquivo de projeto MSBuild mínima

Agora que você tem um arquivo de origem de aplicativo mínimo, você pode criar um arquivo de projeto mínimo para criar o aplicativo. Este arquivo de projeto contém os seguintes elementos:

  • A raiz necessária Project nó.

  • Um ItemGroup o nó para conter elementos de item.

  • Um elemento de item que se refere ao arquivo de origem do aplicativo.

  • A Target o nó para conter as tarefas que são necessárias para construir o aplicativo.

  • A Task elemento para iniciar o compilador do Visual C# para criar o aplicativo.

Para criar um arquivo de projeto MSBuild mínimo

  1. No editor de texto, substitua o texto existente usando estas duas linhas:

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

  2. Inserir este ItemGroup o nó como um elemento filho a Project nó:

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

    Observe que esse ItemGroup já contém um elemento de item.

  3. Adicionar um Target o nó como um elemento filho de Project nó. Nome do nó Build.

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

  4. Inserir este elemento de tarefa como um elemento filho de Target nó:

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

  5. Salvar o arquivo de projeto e o nome de HelloWorld. csproj.

Seu arquivo de projeto mínimo deve ser semelhante o código a seguir:

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

Tarefas no destino de compilação são executadas seqüencialmente. Neste caso, o compilador do Visual C# Csc tarefa é a única tarefa. Ele espera uma lista dos arquivos de origem para compilar e é fornecida pelo valor do Compile item. O Compile item faz referência a apenas um arquivo de origem, Helloworld.cs.

ObservaçãoObservação

No elemento item, você pode usar o caractere curinga asterisco (*) para fazer referência a todos os arquivos que têm a extensão de nome de arquivo. cs, da seguinte maneira:

<Compile Include="*.cs" />

No entanto, não recomendamos o uso de caracteres curinga porque torna a depuração e seletiva direcionamento mais difícil, se os arquivos de origem são adicionados ou excluídos.

Estendendo o caminho para incluir o MSBuild

Antes de poder acessar o MSBuild, você deve estender a variável de ambiente PATH para incluir o.Pasta do NET Framework.

Para estender o caminho para incluir o MSBuild

  • No prompt de comando, digite set PATH=%PATH%;%WINDIR%\Microsoft.Net\Framework\v4.0. Se você tiver outra versão do.NET Framework instalado, altere o número da versão da mesma forma.

    ObservaçãoObservação

    O nome da pasta MSBuild em seu computador pode incluir um número de compilação como, por exemplo, v2.0.50727. Em caso afirmativo, incluir o número de compilação na linha de comando, por exemplo, set PATH=%PATH%;%WINDIR%\Microsoft.Net\Framework\v2.0.50727.

    Como alternativa, se você tiver Visual Studio instalado, você pode usar o Visual Studio Prompt de comando de, que tem um caminho que inclua a pasta do MSBuild.

Usando o arquivo de projeto para criar o aplicativo

Agora, para criar o aplicativo, use o arquivo de projeto que você acabou de criar.

Para criar o aplicativo

  1. No prompt de comando, digite msbuild helloworld.csproj /t:Build.

    Isso cria o destino de compilação do arquivo de projeto Helloworld chamando o compilador do Visual C# para criar o aplicativo Helloworld.

  2. Testar o aplicativo digitando helloworld.

    O Hello, world! mensagem deve ser exibida.

ObservaçãoObservação

Você pode ver mais detalhes sobre a compilação, aumentando o nível de verbosidade. Para definir o nível de verbosidade para "detalhados", digite um destes comandos no prompt de comando:

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

Adicionando propriedades de compilação

Você pode adicionar propriedades de compilação para o arquivo de projeto para controlar ainda mais a compilação. Agora, adicione essas propriedades:

  • Um AssemblyName propriedade para especificar o nome do aplicativo.

  • Um OutputPath propriedade para especificar uma pasta para conter o aplicativo.

Para adicionar propriedades de compilação

  1. Excluir o aplicativo existente digitando del helloworld.exe no prompt de comando.

  2. No arquivo de projeto, inserir PropertyGroup elemento logo após a abertura Project elemento:

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

  3. Adicionar esta tarefa para o destino de compilação antes de Csc tarefa:

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

    O MakeDir tarefa cria uma pasta chamada pelo OutputPath propriedade, fornecida que com esse nome existe atualmente nenhuma pasta.

  4. Adicionar este OutputAssembly de atributo para o Csc tarefa:

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

    Isso instrui o compilador para produzir um assembly nomeado pelo Visual C# a AssemblyName propriedade e colocá-lo na pasta nomeado pelo OutputPath propriedade.

  5. Salve suas alterações.

Seu arquivo de projeto agora deverá ser semelhante o código a seguir:

<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>
ObservaçãoObservação

Recomendamos que você adicione o delimitador de caminho de barra invertida (\) no final do nome da pasta quando você especificar na OutputPath elemento, em vez de adicioná-lo na OutputAssembly atributo da Csc de tarefas. Portanto,

<OutputPath>Bin\</OutputPath>

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

é melhor do que

<OutputPath>Bin</OutputPath>

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

As propriedades de compilação de teste.

Agora você pode criar o aplicativo usando o arquivo de projeto em que você usou as propriedades de compilação para especificar o nome de pasta e o aplicativo de saída.

Para testar as propriedades de compilação

  1. No prompt de comando, digite msbuild helloworld.csproj /t:Build.

    Isso cria a pasta \Bin\ e invoca o compilador do Visual C# para criar o aplicativo MSBuildSample e coloca-o na pasta \Bin\.

  2. Para verificar se a pasta de \Bin\ foi criada e que ele contém o aplicativo MSBuildSample, digite dir Bin.

  3. Testar o aplicativo digitando Bin\MSBuildSample.

    O Hello, world! mensagem deve ser exibida.

Adicionando destinos de compilação

Em seguida, adicione dois destinos mais para o arquivo de projeto, da seguinte maneira:

  • Um destino de limpo exclui arquivos antigos.

  • Um destino de reconstrução que usa o DependsOnTargets atributo para forçar a tarefa de limpeza seja executada antes da tarefa de compilação.

Agora que você tem vários destinos, você pode definir o destino de compilação como destino padrão.

Adicionar destinos de compilação

  1. No arquivo de projeto, adicione esses dois destinos logo após o destino de compilação:

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

    O destino Clean invoca a tarefa de excluir para excluir o aplicativo. O destino de recriação não será executado até que o destino Clean e o destino de compilação executaram. Embora o destino de reconstrução não tenha nenhuma tarefa, ele faz com que o destino Clean para executar antes o destino de compilação.

  2. Adicionar este DefaultTargets atributo para a abertura Project elemento:

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

    Isso define o destino de compilação como destino padrão.

Seu arquivo de projeto agora deverá ser semelhante o código a seguir:

<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>

Os destinos de compilação de teste.

Você pode exercer os novos destinos de compilação para testar esses recursos do arquivo de projeto:

  • Criando a compilação padrão.

  • Definindo o nome do aplicativo no prompt de comando.

  • A exclusão do aplicativo antes de outro aplicativo é compilado.

  • Excluindo o aplicativo sem a criação de outro aplicativo.

Para testar os destinos de compilação

  1. No prompt de comando, digite msbuild helloworld.csproj /p:AssemblyName=Greetings.

    Porque você não usou o /t opção definir explicitamente o destino, o MSBuild é executado o destino de compilação padrão. O /p Alternar substitui o AssemblyName propriedade e concede a ele o novo valor, saudações. Isso faz com que um novo aplicativo, Greetings.exe, para ser criado na pasta \Bin\.

  2. Para verificar se a pasta \Bin\ contém o aplicativo de MSBuildSample e o novo aplicativo Greetings, digite dir Bin.

  3. Teste o aplicativo Greetings digitando Bin\Greetings.

    O Hello, world! mensagem deve ser exibida.

  4. Excluir o aplicativo de MSBuildSample digitando msbuild helloworld.csproj /t:clean.

    Essa opção executa a tarefa de limpeza para remover o aplicativo que tenha o padrão AssemblyName o valor de propriedade, MSBuildSample.

  5. Excluir o aplicativo Greetings digitando msbuild helloworld.csproj /t:clean /p:AssemblyName=Greetings.

    Essa opção executa a tarefa de limpeza para remover o aplicativo que está a determinado AssemblyName o valor de propriedade, saudações.

  6. Para verificar se a pasta \Bin\ agora está vazia, digite dir Bin.

  7. Type msbuild.

    Embora um arquivo de projeto não for especificado, o MSBuild cria o arquivo HelloWorld. csproj porque há apenas um arquivo de projeto na pasta atual. Isso faz com que o aplicativo de MSBuildSample a ser criado na pasta \Bin\.

    Para verificar se a pasta \Bin\ contém o aplicativo MSBuildSample, digite dir Bin.

Criação de forma incremental

Você pode informar o MSBuild para criar um destino somente se os arquivos de origem ou os arquivos de destino para o destino depende foram alterados. MSBuild usa o carimbo de hora de um arquivo para determinar se foi alterado.

Para aumentar incrementalmente

  1. No arquivo de projeto, adicione esses atributos para a destino de compilação de abertura:

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

    Isso especifica que o destino de compilação depende de arquivos de entrada são especificados no Compile grupo de itens, e que o destino de saída é o arquivo do aplicativo.

    O destino de compilação resultante deve se parecer com o código a seguir:

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

  2. Teste o destino de compilação digitando msbuild /v:d no prompt de comando.

    Lembre-se de que HelloWorld. csproj é o arquivo de projeto padrão, e a compilação é o destino padrão.

    O /v:d opção especifica uma descrição detalhada do processo de compilação.

    Essas linhas devem ser exibidas:

    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 ignora o destino de compilação porque nenhum dos arquivos de origem foram alteradas desde a última vez em que o aplicativo foi compilado.

Exemplo

Descrição

O exemplo a seguir mostra um arquivo de projeto que compila um Visual C# aplicativo e registra uma mensagem que contém o nome de arquivo de saída.

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>

Exemplo

Descrição

O exemplo a seguir mostra um arquivo de projeto que compila um Visual Basic aplicativo e registra uma mensagem que contém o nome de arquivo de saída.

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>

O que mais?

Visual Studio pode automaticamente fazer grande parte do trabalho que é mostrado nesta explicação. Para saber como usar o Visual Studio para criar, editar, criar e testar os arquivos de projeto MSBuild, consulte Walkthrough: Usando o MSBuild.

Consulte também

Outros recursos

MSBuild

Referência do MSBuild