Procedura dettagliata: utilizzo di MSBuild per la creazione di un progetto Visual C++

Articolo
06/16/2023

Questa procedura dettagliata illustra come usare MSBuild in un prompt dei comandi per compilare un progetto Visual Studio C++. Si apprenderà come creare un file di progetto basato su .vcxproj XML per un'applicazione console di Visual C++. Dopo aver compilato il progetto, verrà illustrato come personalizzare il processo di compilazione.

Importante

Non usare questo approccio se si intende modificare il file di progetto in un secondo momento usando l'IDE di Visual Studio. Se si crea un .vcxproj file manualmente, l'IDE di Visual Studio potrebbe non essere in grado di modificarlo o caricarlo, soprattutto se il progetto usa caratteri jolly negli elementi del progetto. Per altre informazioni, vedere .vcxproj Struttura .props e file e .vcxproj file e caratteri jolly.

In questa procedura dettagliata vengono illustrate le attività seguenti:

Creazione di file di origine in C++ per il progetto.
Creazione del file di progetto MSBuild in XML.
Uso di MSBuild per compilare il progetto.
Uso di MSBuild per personalizzare il progetto.

Prerequisiti

Per completare questa procedura dettagliata sono necessari questi prerequisiti:

Una copia di Visual Studio, con il carico di lavoro Sviluppo di applicazioni desktop con C++ installato.
Conoscenza generale del sistema MSBuild.

Nota

La maggior parte delle istruzioni di compilazione di basso livello sono contenute nei .targets file e .props definiti nella cartella delle destinazioni predefinite, archiviate nella proprietà $(VCTargetsPath). È qui che troverai file come Microsoft.Cpp.Common.props. Il percorso predefinito per questi file in Visual Studio 2017 è in %VSINSTALLDIR%Common7\IDE\VC\VCTargets\. Visual Studio 2015 e versioni precedenti le hanno archiviate in %ProgramFiles(x86)%\MSBuild\Microsoft.Cpp\v4.0\<version>\.

Nota

La maggior parte delle istruzioni di compilazione di basso livello sono contenute nei .targets file e .props definiti nella cartella delle destinazioni predefinite, archiviate nella proprietà $(VCTargetsPath). È qui che troverai file come Microsoft.Cpp.Common.props. Il percorso predefinito per questi file è in %VSINSTALLDIR%MSBuild\Microsoft\VC\<version>\. L'elemento <version> path è specifico della versione di Visual Studio. v160 È per Visual Studio 2019. Visual Studio 2017 archivia questi file in %VSINSTALLDIR%Common7\IDE\VC\VCTargets\. Visual Studio 2015 e versioni precedenti le hanno archiviate in %ProgramFiles(x86)%\MSBuild\Microsoft.Cpp\v4.0\<version>\.

Creare i file di origine C++

In questa procedura dettagliata viene creato un progetto che ha un file di origine e un file di intestazione. Il file main.cpp di origine contiene la main funzione per l'applicazione console. Il file main.h di intestazione contiene il codice per includere il <iostream> file di intestazione. È possibile creare questi file C++ usando Visual Studio o un editor di testo, come ad esempio Visual Studio Code.

Per creare i file di origine in C++ per il progetto

Creare una cartella per il progetto.

Creare un file denominato main.cpp e aggiungere questo codice al file:

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

Creare un file denominato main.h e aggiungere questo codice al file:

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

Creazione del file di progetto MSBuild in XML

Un file di progetto MSBuild è un file XML che contiene un elemento radice del progetto (<Project>). Nel progetto di esempio che verrà compilato, l'elemento <Project> contiene sette elementi figlio:

Tre tag gruppo di elementi (<ItemGroup>) che consentono di specificare la configurazione e la piattaforma del progetto, il nome file di origine e il nome file di intestazione.
Tre tag importazione (<Import>) che specificano la posizione delle impostazioni di Microsoft Visual C++.
Un tag gruppo di proprietà (<PropertyGroup>) che specifica le impostazioni del progetto.

Per creare il file di progetto MSBuild

Usare un editor di testo per creare un file di progetto denominato myproject.vcxproje quindi aggiungere l'elemento radice <Project> illustrato di seguito. Usare ToolsVersion="14.0" se si usa Visual Studio 2015, ToolsVersion="15.0" se si usa Visual Studio 2017 o ToolsVersion="16.0" se si usa Visual Studio 2019.
```
<Project DefaultTargets="Build" ToolsVersion="16.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
</Project>
```
Inserire gli elementi nei passaggi successivi della procedura tra i tag radice <Project> .

Aggiungere questi due <ProjectConfiguration> elementi figlio in un <ItemGroup> elemento . L'elemento figlio specifica le configurazioni di debug e rilascio per un sistema operativo Windows a 32 bit:

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

Aggiungere un <Import> elemento che specifica il percorso delle impostazioni C++ predefinite per questo progetto:
```
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.default.props" />
```
Aggiungere un elemento gruppo di proprietà (<PropertyGroup>) che specifica due proprietà del progetto e <ConfigurationType><PlatformToolset>. Usare v140 come <PlatformToolset> valore se si usa Visual Studio 2015, v141 se si usa Visual Studio 2017 o v142 se si usa Visual Studio 2019.
```
<PropertyGroup>
  <ConfigurationType>Application</ConfigurationType>
  <PlatformToolset>v142</PlatformToolset>
</PropertyGroup>
```
Aggiungere un <Import> elemento che specifica il percorso delle impostazioni C++ correnti per questo progetto:
```
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
```
Aggiungere un <ClCompile> elemento figlio in un <ItemGroup> elemento . L'elemento figlio specifica il nome del file di origine C/C++ da compilare:
```
<ItemGroup>
  <ClCompile Include="main.cpp" />
</ItemGroup>
```
Nota

<ClCompile> è una destinazione di compilazione ed è definita nella cartella di destinazioni predefinita.
Aggiungere un <ClInclude> elemento figlio in un <ItemGroup> elemento . L'elemento figlio specifica il nome del file di intestazione per il file di origine C/C++:
```
<ItemGroup>
  <ClInclude Include="main.h" />
</ItemGroup>
```
Aggiungere un <Import> elemento che specifica il percorso del file che definisce la destinazione per questo progetto:
```
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Targets" />
```

File di progetto completo

Questo codice mostra il file di progetto completo creato nella procedura precedente. Usare ToolsVersion="15.0" per Visual Studio 2017 o ToolsVersion="14.0" per Visual Studio 2015.

<Project DefaultTargets="Build" ToolsVersion="16.0" xmlns="http://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>
    <PlatformToolset>v142</PlatformToolset>
  </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>

Uso di MSBuild per compilare il progetto

Immettere questo comando al prompt dei comandi per compilare l'applicazione console:

msbuild myproject.vcxproj /p:configuration=debug

MSBuild crea una cartella per i file di output e quindi compila e collega il progetto per generare il Myproject.exe programma. Al termine del processo di compilazione, usare questo comando per eseguire l'applicazione dalla cartella di debug:

myproject

L'applicazione dovrebbe visualizzare "Hello, from MSBuild!" nella finestra della console.

Personalizzazione del progetto

MSBuild consente di eseguire destinazioni di compilazione predefinite, applicare proprietà definite dall'utente e usare strumenti, eventi e istruzioni di compilazione personalizzati. Questa sezione illustra queste attività:

Uso di MSBuild con destinazioni di compilazione.
Uso di MSBuild con proprietà di compilazione.
Uso di MSBuild con gli strumenti e il compilatore a 64 bit.
Uso di MSBuild con set di strumenti diversi.
Aggiunta di personalizzazioni MSBuild.

Uso di MSBuild con destinazioni di compilazione

Una destinazione di compilazione è un set denominato di comandi predefiniti o definiti dall'utente che possono essere eseguiti durante la compilazione. Per specificare una destinazione di compilazione, usare l'opzione della riga di comando di destinazione (/t). Per il myproject progetto di esempio, la destinazione predefinita clean elimina tutti i file nella cartella di debug e crea un nuovo file di log.

Al prompt dei comandi immettere questo comando per pulire myproject:

msbuild myproject.vcxproj /t:clean

Uso di MSBuild con proprietà di compilazione

L'opzione della riga di comando delle proprietà (/p) consente di eseguire l'override di una proprietà nel file di compilazione del progetto. Nel progetto di esempio myproject la configurazione di compilazione di rilascio o di debug viene specificata dalla proprietà Configuration. Il sistema operativo che verrà usato per eseguire l'applicazione compilata viene specificato dalla Platform proprietà .

Al prompt dei comandi immettere questo comando per creare una build di debug dell'applicazione myproject da eseguire in Windows a 32 bit:

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

Si supponga che il progetto di esempio myproject definisca anche una configurazione per Windows a 64 bit e un'altra configurazione per un sistema operativo personalizzato denominato myplatform.

Al prompt dei comandi immettere questo comando per creare una build di versione eseguita in Windows a 64 bit:

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

Al prompt dei comandi immettere questo comando per creare una build di versione per myplatform:

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

Uso di MSBuild con gli strumenti e il compilatore a 64 bit

Se Visual Studio è stato installato in Windows a 64 bit, gli strumenti nativi e cross a 64 bit vengono installati per impostazione predefinita. È possibile configurare MSBuild per usare il compilatore e gli strumenti a 64 bit per compilare l'applicazione impostando la proprietà PreferredToolArchitecture. Questa proprietà non influisce sulle proprietà di configurazione del progetto o dalla piattaforma. Per impostazione predefinita, viene usata la versione a 32 bit degli strumenti. Per specificare la versione a 64 bit del compilatore e degli strumenti, aggiungere questo elemento del gruppo di proprietà al file di Myproject.vcxproj progetto dopo l'elemento Microsoft.Cpp.default.props file <Import /> :

<PropertyGroup>
    <PreferredToolArchitecture>x64</PreferredToolArchitecture>
</PropertyGroup>

Al prompt dei comandi immettere questo comando per usare gli strumenti a 64 bit per compilare l'applicazione:

msbuild myproject.vcxproj /p:PreferredToolArchitecture=x64

Uso di MSBuild con un set di strumenti diverso

Se sono stati installati set di strumenti e librerie per altre versioni di Visual C++, MSBuild può compilare applicazioni per la versione corrente di Visual C++ o per le altre versioni installate. Ad esempio, se Visual Studio 2012 è stato installato, per specificare il set di strumenti di Visual C++ 11.0 per Windows XP, aggiungere questo elemento del gruppo di proprietà al Myproject.vcxproj file di progetto dopo l'elemento Microsoft.Cpp.props file <Import /> :

<PropertyGroup>
    <PlatformToolset>v110_xp</PlatformToolset>
</PropertyGroup>

Per ricompilare il progetto con il set di strumenti di Windows XP di Visual C++ 11.0, immettere questo comando:

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

Aggiunta di personalizzazioni MSBuild

MSBuild offre vari modi per personalizzare il processo di compilazione. Questi articoli illustrano come aggiungere passaggi di compilazione, strumenti ed eventi personalizzati al progetto MSBuild: