MSBuild

Le Microsoft Build Engine (MSBuild) est une plateforme de génération d'applications. MSBuild fournit un schéma XML pour un fichier projet qui contrôle la manière dont la plateforme de génération traite et génère le logiciel. Bien que MSBuild soit intégré à Visual Studio, il n'en est pas dépendant. Les développeurs peuvent orchestrer et générer des produits dans des environnements où Visual Studio n'est pas installé.

Cette rubrique fournit une vue d'ensemble de MSBuild :

• Éléments de base d'un fichier projet MSBuild.

• Utilisation de MSBuild pour générer des projets.

• Fonctionnalités avancées de MSBuild.

• Utilisation de MSBuild par Visual Studio pour générer des projets.

• Pour obtenir un didacticiel d'introduction, consultez Procédures pas à pas : utilisation de MSBuild.

Fichier projet

MSBuild utilise un format de fichier projet XML qui est simple et extensible. Le format du fichier projet MSBuild permet aux développeurs de décrire les éléments qui seront générés et la manière dont ils le seront pour différents systèmes d'exploitation et configurations. De plus, le format de fichier projet permet aux développeurs de créer des règles de génération réutilisables qui peuvent être réparties en fichiers distincts, de telle sorte que les builds puissent être exécutées de façon cohérente sur différents projets du produit.

Les sections suivantes décrivent certains éléments de base du format de fichier projet MSBuild. Pour un didacticiel sur la création d'un fichier projet de base, consultez Procédure pas à pas : création d'un fichier projet MSBuild en partant de zéro.

Propriétés

Les propriétés sont des paires clé/valeur qui peuvent être utilisées pour configurer les générations. Les propriétés sont déclarées en créant un élément portant le nom de la propriété comme enfant d'un élément PropertyGroup. Par exemple, le code suivant crée une propriété nommée BuildDir avec la valeur Build.

<PropertyGroup>

<BuildDir>Build</BuildDir>

</PropertyGroup>

Les propriétés sont référencées dans tout le fichier projet à l'aide de la syntaxe $(NomPropriété). Par exemple, la propriété dans l'exemple serait référencée à l'aide de $(BuildDir). Pour plus d'informations sur les propriétés, consultez Propriétés MSBuild.

Items

Les éléments sont des entrées du système de génération qui représentent généralement des fichiers. Les éléments sont groupés dans différents types d'élément, selon leurs noms d'élément définis par l'utilisateur. Ces types d'éléments peuvent être utilisés comme paramètres des tâches, lesquelles utilisent les éléments pour exécuter les étapes du processus de génération.

Les éléments sont déclarés dans le fichier projet en créant un élément avec le nom du type d'élément comme enfant d'un élément ItemGroup Par exemple, le code suivant crée un type d'élément nommé Compile et composé de deux fichiers.

<ItemGroup>

<Compile Include = "file1.cs"/>

<Compile Include = "file2.cs"/>

</ItemGroup>

Les types d'éléments peuvent être référencés dans tout le fichier projet à l'aide de la syntaxe @(TypeÉlément). Par exemple, le type d'élément dans l'exemple serait référencé avec la syntaxe @(Compile).

Les éléments peuvent être déclarés à l'aide de caractères génériques et peuvent contenir des métadonnées supplémentaires dans le cas de scénarios de génération plus avancés. Pour plus d'informations sur les éléments, consultez Éléments MSBuild.

Tâches

Les tâches sont des unités de code exécutable auxquelles les projets MSBuild ont recours pour exécuter des opérations de génération. Par exemple, une tâche peut compiler des fichiers d'entrée ou exécuter un outil externe. Les tâches peuvent être réutilisées et partagées par plusieurs développeurs dans différents projets.

La logique d'exécution d'une tâche est écrite en code managé et mappée à MSBuild avec l'élément UsingTask. Vous pouvez écrire votre propre tâche en créant un type managé qui implémente l'interface ITask. Pour plus d'informations sur l'écriture de tâches, consultez Écriture de tâches.

MSBuild inclut des tâches courantes que vous pouvez modifier en fonction de vos besoins, par exemple, Copy, qui copie des fichiers, MakeDir, qui crée des répertoires et Csc, qui compile des fichiers de code source Visual C#. Pour obtenir la liste complète des tâches disponibles et des informations sur leur utilisation, consultez Référence des tâches MSBuild.

Une tâche est exécutée dans un fichier projet MSBuild en créant un élément avec le nom de la tâche comme enfant d'un élément Target. En général, les tâches acceptent les paramètres passés comme des attributs de l'élément. Les propriétés et les éléments MSBuild peuvent être utilisés comme des paramètres. Par exemple, le code suivant appelle la tâche MakeDir et lui passe la valeur de la propriété BuildDir déclarée dans l'exemple précédent.

<Target Name="MakeBuildDirectory">

<MakeDir Directories="$(BuildDir)" />

</Target>

Pour plus d'informations sur les tâches, consultez Tâches MSBuild.

Cibles

Les cibles regroupent les tâches selon un ordre particulier et exposent les sections du fichier projet comme points d'entrée du processus de génération. Les cibles sont souvent groupées en sections logiques afin d'accroître la lisibilité et de permettre un agrandissement. L'éclatement des étapes de génération en plusieurs cibles permet d'appeler une partie du processus de génération à partir d'autres cibles sans copier cette section de code dans chaque cible. Par exemple, si plusieurs points d'entrée du processus de génération requièrent la génération de références, vous pouvez créer une cible qui génère les références et exécuter cette cible à partir de chaque point d'entrée nécessaire.

Les cibles sont déclarées dans le fichier projet avec l'élément Target. Par exemple, le code suivant crée une cible nommée Compile, qui appelle ensuite la tâche Csc comportant la liste d'éléments déclarée dans l'exemple précédent.

<Target Name="Compile">

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

</Target>

Dans des scénarios plus avancés, les cibles peuvent être utilisées pour décrire les relations entre chacune d'elles et exécuter une analyse de dépendance, qui permet d'ignorer des sections entières du processus de génération si la cible correspondante est à jour. Pour plus d'informations sur les cibles, consultez Cibles de MSBuild.

Éléments conditionnels

De nombreux éléments MSBuild sont définis de manière conditionnelle, autrement dit, l'attribut Condition apparaît dans l'élément. Le contenu des éléments conditionnels est ignoré, à moins que la condition ait la valeur « true ». Par exemple :

<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

signifie « Si la propriété Configuration n'a pas encore été définie, définissez-la et affectez-lui la valeur Debug ».

Presque tous les éléments MSBuild peuvent avoir un attribut Condition. Pour plus d'informations, consultez Conditions MSBuild.

Respect de la casse

Le schéma XML MSBuild suit les règles XML. Les noms des éléments et des attributs respectent la casse. Toutefois, les noms des propriétés, des éléments et des métadonnées ne respectent pas la casse dans le modèle d'objet MSBuild. Prenons le groupe d'éléments suivant.

<ItemGroup>

<Compile Include="one.cs" />

<comPile Include="two.cs" />

</ItemGroup>

Cela crée le type d'élément Compile, comPile ou toute autre variation au niveau de la casse, et la valeur « one.cs;two.cs » lui est affectée.

Utilisation de MSBuild dans une invite de commandes

Pour exécuter MSBuild à partir d'une invite de commandes, passez un fichier projet à MSBuild.exe, avec les options de ligne de commande appropriées. Les options de ligne de commande vous permettent de définir des propriétés, d'exécuter des cibles spécifiques et de définir d'autres options qui contrôlent le processus de génération. Par exemple, vous utilisez la syntaxe de ligne de commande suivante pour générer le fichier MyProj.proj avec la propriété Configuration ayant Debug comme valeur.

MSBuild.exe MyProj.proj /property:Configuration=Debug

Pour plus d'informations sur les options de ligne de commande MSBuild, consultez Référence de la ligne de commande MSBuild. 

Note de sécurité
Avant de télécharger un projet, déterminez la crédibilité du code.

Concepts avancés

MSBuild peut également être utilisé pour exécuter d'autres opérations, comme l'enregistrement des erreurs, des avertissements et autres messages dans la console ou des périphériques de sortie, l'exécution d'une analyse de dépendance sur les cibles et le traitement par lots des tâches et des cibles sur les métadonnées d'élément. Pour plus d'informations sur ces concepts avancés, consultez Concepts avancés de MSBuild.

Utilisation de MSBuild dans Visual Studio

Visual Studio utilise le format de fichier projet MSBuild pour stocker les informations de génération des projets managés. Les paramètres de projet ajoutés ou modifiés à l'aide de l'interface Visual Studio sont répercutés dans le fichier .*proj généré pour chaque projet. Visual Studio utilise une instance hébergée de MSBuild pour générer des projets managés. Cela signifie qu'un projet managé peut être généré dans Visual Studio ou à partir d'une invite de commandes (même si Visual Studio n'est pas installé) ; les résultats seront identiques.

Pour un didacticiel sur l'utilisation de MSBuild dans Visual Studio, consultez Procédures pas à pas : utilisation de MSBuild.

Multi-ciblage

Visual Studio vous permet de compiler une application pour l'exécuter sur n'importe quelle version du .NET Framework. Par exemple, vous pouvez compiler une application qui s'exécutera sur le .NET Framework version 2.0 et compiler la même application pour qu'elle s'exécute sur le .NET Framework version 4. Le multi-ciblage désigne la possibilité de compiler en plusieurs Frameworks.

Voici une partie des avantages offerts par le multi-ciblage :

• Vous pouvez développer des applications qui ciblent des versions antérieures du .NET Framework (par exemple, les versions 2.0, 3.0 et 3.5).

• Vous pouvez cibler des Frameworks autres que le .NET Framework (par exemple, Silverlight).

• Vous pouvez cibler unprofil Framework, qui est un sous-ensemble prédéfini d'une version cible du .NET Framework.

• Si des Service Packs pour le .NET Framework version 4 sont publiés, vous pouvez les cibler.

• Le multi-ciblage garantit qu'une application utilise uniquement les fonctionnalités disponibles dans la version cible du .NET Framework.

• Pour plus d'informations, consultez Multi-ciblage de MSBuild.

Rubriques connexes

Référence

• Référence MSBuild
  Renvoie aux rubriques contenant les informations de référence.

• Glossaire MSBuild
  Définit les termes courants relatifs à MSBuild.