Procédure pas à pas : création d'un fichier projet MSBuild en partant de zéro

Article
08/10/2011

Les langages de programmation qui ciblent le .NET Framework, par exemple, Visual C# et Visual Basic, utilisent des fichiers projet MSBuild pour décrire et contrôler le processus de génération d'application. Lorsque vous utilisez Visual Studio pour créer un fichier projet MSBuild, le XML approprié est ajouté automatiquement au fichier. Toutefois, vous pouvez trouver utile de savoir comment le XML est organisé et comment il est possible de le modifier pour contrôler une build. Cette procédure pas à pas indique comment créer de façon incrémentielle un fichier projet de base, en utilisant uniquement un éditeur de texte. La procédure pas à pas suit ces étapes :

Créer un fichier source d'application minimal.
Créer un fichier projet MSBuild minimal.
Étendre la variable d'environnement PATH pour inclure MSBuild.
Générer l'application à l'aide du fichier projet.
Ajouter des propriétés pour contrôler la build.
Contrôler la build en modifiant les valeurs de propriétés.
Ajouter des cibles à la build.
Contrôler la build en spécifiant des cibles.
Générer de manière incrémentielle.

Cette procédure pas à pas indique comment générer le projet à l'invite de commandes et examiner les résultats. Pour plus d'informations sur MSBuild et sur son exécution à l'invite de commandes, consultez Procédures pas à pas : utilisation de MSBuild.

Pour exécuter la procédure pas à pas, le .NET Framework (version 2.0, 3.5 ou 4) doit être installé car il inclut MSBuild et le compilateur Visual C#, qui sont obligatoires pour cette procédure.

Création d'une application minimale

Cette section indique comment créer un fichier source d'application Visual C# minimal à l'aide d'un éditeur de texte.

Pour créer l'application minimale

À l'invite de commandes, recherchez le dossier dans lequel vous souhaitez créer l'application, par exemple, \Mes documents\ ou \Bureau\.
Tapez md HelloWorld pour créer un sous-dossier nommé \HelloWorld\.
Tapez cd HelloWorld pour indiquer le nouveau dossier.

Démarrez le Bloc-notes ou un autre éditeur de texte, puis tapez le code suivant.

using System;

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

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

Enregistrez ce fichier de code source et nommez-le Helloworld.cs.
Générez l'application en tapant csc helloworld.cs à l'invite de commandes.
Testez l'application en tapant helloworld à l'invite de commandes.

Le message Hello, world! doit s'afficher.
Supprimez l'application en tapant del helloworld.exe à l'invite de commandes.

Création d'un fichier projet MSBuild minimal

Maintenant que vous disposez d'un fichier source d'application minimal, vous pouvez créer un fichier projet minimal pour générer l'application. Ce fichier projet contient les éléments suivants :

Le nœud racine Project obligatoire.
Un nœud ItemGroup pour contenir des éléments item.
Un élément item qui fait référence au fichier source d'application.
Un nœud Target pour contenir les tâches nécessaires à la génération de l'application.
Un élément Task pour lancer le compilateur Visual C# afin de générer l'application.

Pour créer un fichier projet MSBuild minimal

Dans l'éditeur de texte, remplacez le texte existant en utilisant ces deux lignes :
```
<Project xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
</Project>
```
Insérez ce nœud ItemGroup en tant qu'élément enfant du nœud Project.
```
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
```
Remarquez que ce nœud ItemGroup contient déjà un élément item.
Ajoutez un nœud Target en tant qu'élément enfant du nœud Project. Nommez le nœud Build.
```
  <Target Name="Build">
  </Target>
```
Insérez cet élément de tâche en tant qu'élément enfant du nœud Target :
```
    <Csc Sources="@(Compile)"/>
```
Enregistrez ce fichier projet et nommez-le Helloworld.csproj.

Votre fichier projet minimal doit ressembler au code suivant :

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

Les tâches dans la cible Build sont exécutées de manière séquentielle. Dans ce cas, la tâche Csc du compilateur Visual C# est la seule tâche. Elle attend la liste des fichiers sources à compiler, fournie par la valeur de l'élément Compile. L'élément Compile ne référence qu'un seul fichier source, Helloworld.cs.

Notes

Dans l'élément item, vous pouvez utiliser le caractère générique astérisque (*) pour référencer tous les fichiers qui ont l'extension de nom de fichier .cs, comme suit :

Toutefois, nous ne recommandons pas l'utilisation de caractères génériques, car ils rendent le débogage et le ciblage sélectif plus difficile si des fichiers sources sont ajoutés ou supprimés.

Extension du chemin d'accès pour inclure MSBuild

Pour pouvoir accéder à MSBuild, vous devez étendre la variable d'environnement PATH pour inclure le dossier .NET Framework.

Pour étendre le chemin d'accès afin d'inclure MSBuild

À l'invite de commandes, tapez set PATH=%PATH%;%WINDIR%\Microsoft.Net\Framework\v4.0. Si une autre version du .NET Framework est installée, modifiez le numéro de version en conséquence.

Notes

Le nom du dossier MSBuild sur votre ordinateur peut inclure un numéro de build tel que v2.0.50727. Dans ce cas, ajoutez le numéro de build sur la ligne de commande, par exemple, set PATH=%PATH%;%WINDIR%\Microsoft.Net\Framework\v2.0.50727.

Si Visual Studio est installé, vous pouvez également utiliser l'Invite de commandes de Visual Studio, dont le chemin d'accès inclut le dossier MSBuild.

Utilisation du fichier projet pour générer l'application

À présent, pour générer l'application, utilisez le fichier projet que vous venez de créer.

Pour générer l'application

À l'invite de commandes, tapez msbuild helloworld.csproj /t:Build.

Cela génère la cible Build du fichier projet Helloworld en appelant le compilateur Visual C# pour créer l'application Helloworld.
Testez l'application en tapant helloworld.

Le message Hello, world! doit s'afficher.

Notes

Pour afficher plus de détails à propos de la build, augmentez le niveau de commentaires. Pour définir le niveau de commentaires sur "détaillé", tapez l'une ou l'autre de ces commandes à l'invite de commandes :

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

Ajout de propriétés de génération

Vous pouvez ajouter des propriétés de génération au fichier projet pour contrôler davantage la build. Ajoutez maintenant ces propriétés :

Une propriété AssemblyName pour spécifier le nom de l'application.
Une propriété OutputPath pour spécifier un dossier qui contiendra l'application.

Pour ajouter des propriétés de génération

Supprimez l'application existante en tapant del helloworld.exe à l'invite de commandes.

Dans le fichier projet, insérez cet élément PropertyGroup juste après l'élément Project ouvrant :

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

Ajoutez cette tâche à la cible Build, juste avant la tâche Csc :
```
    <MakeDir Directories="$(OutputPath)"      Condition="!Exists('$(OutputPath)')" />
```
La tâche MakeDir crée un dossier nommé par la propriété OutputPath, à condition qu'aucun dossier existant ne porte déjà ce nom.
Ajoutez cet attribut OutputAssembly à la tâche Csc :
```
<Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
```
Le compilateur Visual C# doit alors créer un assembly nommé par la propriété AssemblyName et le placer dans le dossier nommé par la propriété OutputPath.
Enregistrez les modifications apportées.

Votre fichier projet doit maintenant ressembler au code suivant :

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

Notes

Nous vous recommandons d'ajouter la barre oblique inverse (\) comme délimiteur de chemin à la fin du nom de dossier lorsque vous le spécifiez dans l'élément OutputPath, au lieu de l'ajouter dans l'attribut OutputAssembly de la tâche Csc. Par conséquent,

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

convient mieux que

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

Test des propriétés de génération

Maintenant, vous pouvez générer l'application à l'aide du fichier projet dans lequel vous avez utilisé les propriétés de génération pour spécifier le nom du dossier de sortie et de l'application.

Pour tester les propriétés de génération

À l'invite de commandes, tapez msbuild helloworld.csproj /t:Build.

Cela crée le dossier \Bin\, puis appelle le compilateur Visual C# pour créer l'application MSBuildSample dans le dossier \Bin\.
Pour vérifier que le dossier \Bin\ a été créé et qu'il contient l'application MSBuildSample, tapez dir Bin.
Testez l'application en tapant Bin\MSBuildSample.

Le message Hello, world! doit s'afficher.

Ajout de cibles Build

Ensuite, ajoutez deux cibles supplémentaires au fichier projet, comme suit :

Une cible Clean qui supprime les fichiers anciens.
Une cible Rebuild qui utilise l'attribut DependsOnTargets pour forcer l'exécution de la tâche Clean avant la tâche Build.

Maintenant que vous avez plusieurs cibles, vous pouvez définir la cible Build comme cible par défaut.

Pour ajouter des cibles Build

Dans le fichier projet, ajoutez ces deux cibles juste après la cible Build :
```
  <Target Name="Clean" >
    <Delete Files="$(OutputPath)$(AssemblyName).exe" />
  </Target>
  <Target Name="Rebuild" DependsOnTargets="Clean;Build" />
```
La cible Clean appelle la tâche Delete pour supprimer l'application. La cible Rebuild ne s'exécute pas tant que les cibles Clean et Build n'ont pas été exécutées. Bien que la cible Rebuild ne possède pas de tâche, elle provoque l'exécution de la cible Clean avant celle de la cible Build.
Ajoutez cet attribut DefaultTargets à l'élément Project d'ouverture :
```
<Project DefaultTargets="Build" xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
```
Cela définit la cible Build comme cible par défaut.

Votre fichier projet doit maintenant ressembler au code suivant :

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

Test des cibles Build

Vous pouvez tester les nouvelles cibles de génération pour essayer les fonctionnalités suivantes du fichier projet :

Génération de la build par défaut.
Définition du nom d'application à l'invite de commandes.
Suppression de l'application avant la génération d'une autre application.
Suppression de l'application sans générer une autre application.

Pour tester les cibles de génération

À l'invite de commandes, tapez msbuild helloworld.csproj /p:AssemblyName=Greetings.

Étant donné que vous n'avez pas utilisé le commutateur /t pour définir la cible explicitement, MSBuild exécute la cible Build par défaut. Le commutateur /p substitue la propriété AssemblyName et lui attribue la nouvelle valeur Greetings. Cela provoque la création d'une application, Greetings.exe, dans le dossier \Bin\.
Pour vérifier que le dossier \Bin\ contient à la fois l'application MSBuildSample et la nouvelle application Greetings, tapez dir Bin.
Testez l'application Greetings en tapant Bin\Greetings.

Le message Hello, world! doit s'afficher.
Supprimez l'application MSBuildSample en tapant msbuild helloworld.csproj /t:clean.

Cela exécute la tâche Clean afin de supprimer l'application qui a la valeur de propriété AssemblyName par défaut, à savoir MSBuildSample.
Supprimez l'application Greetings en tapant msbuild helloworld.csproj /t:clean /p:AssemblyName=Greetings

Cela exécute la tâche Clean afin de supprimer l'application qui a la valeur de propriété AssemblyName donnée, à savoir MSBuildSample.
Pour vérifier que le dossier \Bin\ est maintenant vide, tapez dir Bin.
Tapez msbuild

Bien qu'aucun fichier projet ne soit spécifié, MSBuild génère le fichier helloworld.csproj car le dossier actif ne contient qu'un seul fichier projet. Cela provoque la création de l'application MSBuildSample dans le dossier \Bin\.

Pour vérifier que le dossier \Bin\ contient l'application MSBuildSample, tapez dir Bin.

Génération de façon incrémentielle

Vous pouvez demander à MSBuild de générer une cible uniquement si les fichiers sources ou les fichiers cibles dont dépend la cible ont changé. MSBuild utilise l'horodatage d'un fichier pour déterminer s'il a changé.

Pour effectuer des générations incrémentielles

Dans le fichier projet, ajoutez ces attributs à la cible Build d'ouverture :

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

Cela spécifie que la cible Build dépend des fichiers d'entrée spécifiés dans le groupe d'éléments Compile, et que la cible de sortie est le fichier d'application.

La cible Build résultante doit ressembler au code suivant :

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

Testez la cible Build en tapant msbuild /v:d à l'invite de commandes.

Souvenez-vous qu'helloworld.csproj est le fichier projet par défaut et que Build est la cible par défaut.

Le commutateur /v:d spécifie une description détaillée pour le processus de génération.

Ces lignes doivent apparaître :

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 ignore la cible Build car aucun des fichiers sources n'a changé depuis la dernière génération de l'application.

Exemple

Description

L'exemple suivant affiche un fichier projet qui compile une application Visual C# et enregistre un message contenant le nom du fichier de sortie.

Code

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

Exemple

Description

L'exemple suivant affiche un fichier projet qui compile une application Visual Basic et enregistre un message contenant le nom du fichier de sortie.

Code

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

Quoi d'autre ?

Visual Studio peut effectuer automatiquement une grande partie des tâches décrites dans cette procédure pas à pas. Pour apprendre à utiliser Visual Studio afin de créer, modifier, générer et tester des fichiers projet MSBuild, consultez Procédures pas à pas : utilisation de MSBuild.

Voir aussi

Autres ressources

MSBuild

Référence MSBuild

Partager via

Procédure pas à pas : création d'un fichier projet MSBuild en partant de zéro

Création d'une application minimale

Pour créer l'application minimale

Création d'un fichier projet MSBuild minimal

Pour créer un fichier projet MSBuild minimal

Extension du chemin d'accès pour inclure MSBuild

Pour étendre le chemin d'accès afin d'inclure MSBuild

Utilisation du fichier projet pour générer l'application

Pour générer l'application

Ajout de propriétés de génération

Pour ajouter des propriétés de génération

Test des propriétés de génération

Pour tester les propriétés de génération

Ajout de cibles Build

Pour ajouter des cibles Build

Test des cibles Build

Pour tester les cibles de génération

Génération de façon incrémentielle

Pour effectuer des générations incrémentielles

Exemple

Description

Code

Exemple

Description

Code

Quoi d'autre ?

Voir aussi

Autres ressources

Ressources supplémentaires