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

Artigo
03/12/2013

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

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

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

Pré-requisitos

Você precisará do seguinte para concluir essa explicação passo a passo:

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

Criando os arquivos de origem do C++

Nesta explicação passo-a-passo você criará um projeto que tem um arquivo de origem e um arquivo de cabeçalho.O arquivo de origem main.cpp contém a função principal para o aplicativo de console.O arquivo de cabeçalho main.h contém o código para incluir o arquivo de cabeçalho de iostream.Você pode criar esses arquivos de 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 o projeto.

Crie um arquivo chamado main.cpp e adicione o seguinte código ao arquivo:

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

Crie um arquivo chamado main.h e adicione o seguinte código ao arquivo:

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

Criando XML MSBuild Arquivo

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

Três marcas de grupo de item (<ItemGroup>) que especificam a configuração e a plataforma do projeto, o nome do arquivo de origem, e o nome de arquivo do cabeçalho.
Três marcas de importação (<Import>) que especificam o local de configurações do Microsoft Visual C++ .
Uma tag de grupo de propriedade (<PropertyGroup>) que especifica as configurações do projeto.

Para criar o arquivo de projeto do MSBuild

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

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

<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 elemento de <Import/> que especifica o caminho das configurações de opção C++ para este projeto:
```
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.default.props" />
```

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

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

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

Conclua o Arquivo de projeto

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 MSBuild para compilar seu Projeto

Digite o seguinte comando no prompt de comando para compilar o aplicativo de console:

msbuild myproject.vcxproj /p:configuration=debug

MSBuild cria um diretório para os arquivos de saída e em seguida, cria e links seu projeto para gerar o programa de Myproject.exe.Após o processo de compilação, use o seguinte comando para executar o aplicativo:

myproject

O aplicativo deve exibir “hello, world” do MSBuild na janela do console.

Personalizando seu Projeto

MSBuild permite que você execute destinos predefinidos de compilação, para aplicar propriedades definidos pelo usuário, e para usar ferramentas personalizadas, eventos, e etapas de compilação.Esta seção mostra as seguintes tarefas:

Usando MSBuild com alvos de compilação.
Usando MSBuild com propriedades de compilação.
Usando MSBuild com conjuntos de ferramentas diferentes.
Adicionando personalizações de MSBuild .

Usando MSBuild com alvos de compilação

Um destino de compilação é chamado um conjunto 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) especificar um destino de compilação.No caso de projeto de myproject , o destino pré-definido de clean excluir todos os arquivos na pasta de depuração e cria um novo arquivo de log.

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

msbuild myproject.vcxproj /t:clean

Usando MSBuild com propriedades de compilação

A opção de linha de comando de propriedade (/p) permite que você substitua uma propriedade no arquivo de compilação do projeto.No projeto de myproject , a versão ou a configuração de compilação de depuração são especificadas pela propriedade de Configuration .E sistema operacional que destina-se a executar o aplicativo criado é especificado pela propriedade de Platform .

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

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

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

No prompt de comando, digite o seguinte comando criar uma compilação de versã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 criar uma compilação de versão para myplatform.

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

Usando MSBuild com um conjunto diferente de ferramentas

Se você tem as bibliotecas de Visual C++ 9,0 e 10,0 (conjuntos de ferramentas) instalado, MSBuild pode criar aplicativos para ou Visual C++ 9,0 ou 10,0.Para especificar o kit de ferramentas de Visual C++ 9,0, adicione o seguinte elemento do grupo de propriedade para o arquivo de projeto de Myproject.vcxproj após o elemento de Microsoft.Cpp.props <Import /> :

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

Para recriar o seu projeto com o kit de ferramentas de Visual C++ 9,0, digite qualquer um dos seguintes comandos:

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

Adicionando personalizações do MSBuild

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

Partilhar via