Demonstra Passo a passo: Usando o MSBuild para criar um projeto do Visual C++

Artigo
08/04/2011

Esta explicação passo a passo demonstra como usar MSBuild para criar um Visual C++ o projeto em um prompt de comando. Você aprenderá a criar os arquivos de origem do C++ e um arquivo de projeto baseado em XML para um Visual C++ aplicativo de console. Após compilar o projeto, você aprenderá como personalizar o processo de compilação.

Essa explicação passo a passo ilustra as seguintes tarefas:

Criando os arquivos de origem do C++ para seu projeto.
Criando o XML MSBuild arquivo de projeto.
Usando MSBuild para construir seu projeto.
Usando MSBuild para personalizar o seu projeto.

Pré-requisitos

Você precisa fazer o seguinte para concluir este passo a passo:

Visual Studio 2010
Uma compreensão geral de como o MSBuild do sistema.

Criar os arquivos de origem do C++

Esta explicação passo a passo, você criará um projeto que tem um arquivo de origem e um arquivo de cabeçalho. O main.cpp do arquivo de origem contém a função principal para o aplicativo de console. O main.h do arquivo de cabeçalho contém o código para incluir o arquivo de cabeçalho iostream. Você pode criar esses arquivos C++ usando Visual Studio ou um editor de texto.

Para criar os arquivos de origem do C++ para seu projeto.

Crie um diretório para seu projeto.

Criar um arquivo chamado main.cpp e adicione o seguinte código para este arquivo:

// main.cpp : the application source code.
#include <iostream>
#include "main.h"
int main()
{
   std::cout << "Hello, from MSBuild!\n";
   return 0;
}

Criar um arquivo chamado main.h e adicione o seguinte código para este arquivo:

// main.h: the application header code.
/* Additional source code to include. */

Criando o arquivo de projeto MSBuild XML

Um MSBuild arquivo de projeto é um arquivo XML que contém um elemento raiz do projeto (<Project>). No projeto de exemplo a seguir, <Project> elemento contém sete elementos-filho:

Nome do arquivo de três marcas de grupo de item (<ItemGroup>) que especificam a configuração de projeto e plataforma, nome do arquivo de fonte e cabeçalho.
Três Importar tags (<Import>) que especifique o local da Microsoft Visual C++ configurações.
Uma marca de grupo de propriedade (<PropertyGroup>) que especifica as configurações do projeto.

Para criar o arquivo de projeto MSBuild

Use um editor de texto para criar um arquivo de projeto chamado myproject.vcxproj, e em seguida, adicione a seguinte raiz <Project> elemento. Inserir os elementos nas etapas do procedimento a seguir entre a raiz <Project> marcas:
```
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns=https://schemas.microsoft.com/developer/msbuild/2003>
</Project>
```

Adicione os seguintes dois <ProjectConfiguration> elementos filho em <ItemGroup> elemento. O elemento filho Especifica a depuração e configurações para um sistema de operacional do Windows de 32 bits de versão:

<ItemGroup>
   <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
   </ProjectConfiguration>
   <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
   </ProjectConfiguration>
</ItemGroup>

Adicione o seguinte <Import/> elemento que especifica o caminho das configurações padrão do C++ para este projeto:
```
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.default.props" />
```

Adicione o seguinte elemento propriedade grupo (<PropertyGroup>) que especifica as duas propriedades do projeto:

<PropertyGroup>
   <ConfigurationType>Application</ConfigurationType>
   <ShowAllFiles>false</ShowAllFiles>
</PropertyGroup>

Adicione o seguinte <Import/> elemento que especifica o caminho das configurações atuais do C++ para este projeto:
```
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
```
Adicione o seguinte <ClCompile> elemento filho na <ImportGroup> elemento. O elemento filho Especifica o nome do arquivo de origem de C/C++ para compilar:
```
<ItemGroup>
   <ClCompile Include="main.cpp" />
</ItemGroup>
```
Adicione o seguinte <ClInclude> elemento filho na <ImportGroup> elemento. O elemento filho Especifica o nome do arquivo de cabeçalho para o arquivo de origem do C/C++:
```
<ItemGroup>
   <ClInclude Include="main.h" />
</ItemGroup>
```
Adicione o seguinte <Import> elemento que especifica o caminho do arquivo que define o destino deste projeto:
```
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Targets" />
```

Arquivo de projeto completo

O código a seguir mostra o arquivo de projeto completo que você criou no procedimento anterior.

<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.default.props" />
  <PropertyGroup>
    <ConfigurationType>Application</ConfigurationType>
    <ShowAllFiles>false</ShowAllFiles>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)/Microsoft.Cpp.props" />
  <ItemGroup>
    <ClCompile Include="main.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="main.h" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Targets" />
</Project>

Usando o MSBuild para construir seu projeto.

Digite o seguinte comando no prompt de comando para criar seu aplicativo de console:

msbuild myproject.vcxproj /p:configuration=debug

MSBuildcria um diretório para arquivos de saída, compila e vincula o seu projeto para gerar o programa Myproject.exe. Após a conclusão do processo de compilação, use o seguinte comando para executar o aplicativo:

myproject

O aplicativo deve exibir "Olá, do MSBuild!" na janela do console.

Personalizando o seu projeto.

MSBuildpermite que você executar os destinos de compilação predefinidos, aplicar propriedades definidas pelo usuário e usar ferramentas personalizadas, eventos e etapas de compilação. Esta seção ilustra as seguintes tarefas:

Usando MSBuild com criar destinos.
Usando MSBuild com criar propriedades.
Usando MSBuild com diferentes conjuntos de ferramentas.
Adicionando MSBuild personalizações.

Usando o MSBuild com destinos de compilação

A Construir o destino é um conjunto nomeado de comandos predefinidos ou definidos pelo usuário que podem ser executadas durante a compilação. Use a opção de linha de comando de destino (/t) para especificar um destino de compilação. No caso do myproject o projeto de exemplo, predefinido clean destino exclui todos os arquivos na pasta debug e cria um novo arquivo de log.

No prompt de comando, digite o seguinte comando para limpar myproject.

msbuild myproject.vcxproj /t:clean

Usando o MSBuild com propriedades de compilação

A opção de propriedade de linha de comando (/p) permite que você substitua uma propriedade no seu arquivo de compilação do projeto. No myproject especificada pela configuração de compilação de projeto, o lançamento ou a depuração de exemplo do Configuration propriedade. E o sistema operacional que destina-se para executar o aplicativo compilado é especificado pelo Platform propriedade.

No prompt de comando, digite o seguinte comando para criar uma compilação de depuração da myproject aplicativo que se destina a ser executado no Windows de 32 bits.

msbuild myproject.vcxproj /p:configuration=debug /p:platform=win32

Suponha que o myproject exemplo de projeto também define uma configuração para o Windows de 64 bits e outra configuração para um sistema de operacional personalizado denominado myplatform.

No prompt de comando, o tipo, o seguinte comando para criar uma versão de compilação que é executado no Windows de 64 bits.

msbuild myproject.vcxproj /p:configuration=release /p:platform=x64

No prompt de comando, digite o seguinte comando para criar uma versão de compilação para myplatform.

msbuild myproject.vcxproj /p:configuration=release /p:platform=myplatform

Usando o MSBuild com um conjunto de ferramentas diferente

Se você tiver que ambos os Visual C++ 9.0 e 10.0 bibliotecas (conjuntos de ferramentas) instaladas, MSBuild podem criar aplicativos para um Visual C++ 9.0 ou 10.0. Para especificar o Visual C++ 9.0 conjunto de ferramentas, adicione o seguinte elemento de grupo de propriedade para o arquivo de projeto de Myproject.vcxproj após o Microsoft.Cpp.props <Import/> elemento:

<PropertyGroup>
    <PlatformToolset>v90</PlatformToolset>
</PropertyGroup>

Para reconstruir seu projeto com o Visual C++ 9.0 conjunto de ferramentas, digite um dos seguintes comandos:

msbuild myproject.vcxproj /p:PlatformToolset=v90 /t:rebuild 
msbuild myproject.vcxproj /t:rebuild

Adicionando personalizações do MSBuild

MSBuildfornece várias maneiras para personalizar o processo de compilação. Os tópicos a seguir mostram como adicionar etapas de compilação personalizada, ferramentas e eventos para seu MSBuild projeto:

Compartilhar via