MSBuild

Article
03/12/2013

Microsoft Build Engine est une plateforme pour générer des applications.Cette moteur, également appelé 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.Visual Studio utilise MSBuild, mais il ne dépend pas de Visual Studio. En appelant msbuild.exe sur votre fichier projet ou solution, vous pouvez orchestrer et générer des produits dans les environnements où Visual Studio n'est pas installé.

Visual Studio utilise MSBuild pour charger et générer des projets managés.Les fichiers projet dans Visual Studio (.csproj, .vbproj, vcxproj, etc.) contiennent le code XML MSBuild qui s'exécute lorsque vous générez un projet à l'aide de l'IDE.Les projets Visual Studio importent tous les paramètres et processus de génération nécessaires pour effectuer le travail de développement classique, mais vous pouvez les étendre ou modifier Visual Studio ou à l'aide d'un éditeur XML.

Les exemples suivants illustrent lorsque vous pouvez exécuter les builds à l'aide d'une ligne de commande MSBuild au lieu de l'IDE de Visual Studio.

Visual Studio n'est pas installé.
Vous souhaitez utiliser la version 64 bits de MSBuild.Cette version MSBuild est généralement inutile, mais elle permet à MSBuild d'accéder à plus de mémoire.
Vous souhaitez effectuer une génération dans plusieurs processus.Toutefois, vous pouvez utiliser l'IDE pour obtenir le même résultat sur des projets en C++ et, à partir de Visual Studio 2012, le c.
Modifier le système de génération.Par exemple, vous pouvez activer les actions suivantes :
- Prétraitez les fichiers avant qu'ils atteignent le compilateur.
- Copiez les sorties de génération vers un autre emplacement.
- Créez les fichiers compressés les sorties de génération.
- Effectuez une étape de post-traitement.Par exemple, vous pouvez emboutir un assembly avec une version différente.

Vous pouvez écrire le code dans l'IDE de Visual Studio mais exécutez des générations à l'aide de MSBuild.Comme autre solution, vous pouvez générer le code dans l'IDE sur un ordinateur de développement mais utiliser une ligne de commande MSBuild pour générer le code qui est intégré plusieurs développeurs.

[!REMARQUE]

Vous pouvez utiliser Team Foundation Build automatiquement pour compiler, tester, puis déployer votre application.Votre système de génération peut exécuter automatiquement des builds lorsque les développeurs archivent le code (par exemple, dans le cadre d'une stratégie d'intégration continue) ou selon une planification (par exemple, une build nocturne de test de vérification de build).Team Foundation Build compile votre code à l'aide de MSBuild.Pour plus d'informations, consultez Génération de l'application.

Cette rubrique fournit une vue d'ensemble de MSBuild.Pour obtenir un didacticiel d'introduction, consultez Procédures pas à pas : utilisation de MSBuild.

Dans cette rubrique

Utilisation de MSBuild dans une invite de commandes
Fichier projet
- Propriétés
- Items
- Tâches
- Cibles
Journaux de génération
Utilisation de MSBuild dans Visual Studio
Multi-ciblage

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.

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.En outre, le format de fichier projet permet aux développeurs de créer des règles de génération réutilisables qui peuvent être factorisées dans des fichiers séparés afin que les builds puissent être exécutées de façon cohérente sur différents projets dans le produit.

Les sections suivantes décrivent certains éléments de base du format de fichier projet d' 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 qui a une valeur d' Build.

<PropertyGroup>
    <BuildDir>Build</BuildDir>
</PropertyGroup>

Vous pouvez définir une propriété de façon conditionnelle en définissant un attribut d' Condition dans l'élément.Le contenu des éléments conditionnels est ignoré, à moins que la condition ait la valeur true.Dans l'exemple suivant, l'élément d' Configuration est défini s'il n'a pas encore été défini.

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

Les propriétés sont référencées dans tout le fichier projet à l'aide de la syntaxe $(NomPropriété).Par exemple, vous pouvez référencer des propriétés dans les exemples précédents à l'aide de $(BuildDir) et d' $(Configuration).

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 et 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 ItemGroupPar 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).

Dans MSBuild, l'élément et d'attributs respectent la casse.Toutefois, la propriété, l'élément, et les noms de métadonnées ne sont pas.L'exemple suivant crée le type d'élément Compile, comPile, ou tout autre variante de l'événement, et donne au type d'élément la valeur « one.cs ; two.cs ».

<ItemGroup>
  <Compile Include="one.cs" />
  <comPile Include="two.cs" />
</ItemGroup>

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 les tâches courantes que vous pouvez modifier pour répondre à vos besoins.Les exemples sont Copie, qui copie les 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 pour améliorer la lisibilité et pour tenir compte de l'expansion.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 des références d'être générées, vous pouvez créer une cible qui génère des références puis exécutez cette cible pour chaque point d'entrée où elle est requis.

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 les scénarios plus avancés, les cibles peuvent être utilisées pour décrire des relations entre une des autres et exécuter une analyse de dépendance afin que les sections entières du processus de génération puissent être ignorées si cette cible est à jour.Pour plus d'informations sur les cibles, consultez Cibles de MSBuild.

Journaux de génération

Vous pouvez signaler des erreurs de build, des avertissements, et des messages à une console ou un périphérique de sortie différent.Pour plus d'informations, consultez Obtention de journaux de génération avec MSBuild et Journalisation dans 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 qui sont ajoutés ou modifiés à l'aide de l'interface d' Visual Studio sont répercutées dans. fichier de *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 à une invite de commandes (même si Visual Studio n'est pas installé), et les résultats sont 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 pour l'exécuter sur le.NET Framework 2.0 sur une plateforme 32 bits, et vous pouvez compiler la même application de s'exécuter sur le .NET Framework 4,5 sur une plateforme 64 bits.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 les versions cibles du. Net Framework 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 un Service Pack pour la version actuelle du .NET Framework est relâché, vous pouvez cibler le.
Le multi-ciblage garantit qu'une application utilise uniquement les fonctionnalités disponibles dans la version cible du. Net Framework et la plateforme.

Pour plus d'informations, consultez Vue d'ensemble du multi-ciblage MSBuild.

Rubriques connexes

Titre	Description
Procédure pas à pas : création d'un fichier projet MSBuild en partant de zéro	Indique comment créer de façon incrémentielle un fichier projet de base, en utilisant uniquement un éditeur de texte.
Procédures pas à pas : utilisation de MSBuild	Présente les blocs de constructions de MSBuild et indique comment écrire, manipuler, et déboguer des projets MSBuild sans fermer l'IDE de Visual Studio.
Concepts MSBuild	Présente les quatre blocs de constructions de MSBuild : propriétés, éléments, cibles et tâches.
Éléments MSBuild	Décrit les concepts généraux sous-jacents au format de fichier MSBuild et la manière dont les éléments s'ajustent les uns aux autres.
Propriétés MSBuild	Présente les propriétés et les collections de propriétés.Les propriétés sont des paires clé/valeur qui peuvent être utilisées pour configurer les générations.
Cibles de MSBuild	Explique comment grouper les tâches dans un ordre particulier et autoriser des sections du processus de génération à être appelées sur la ligne de commande.
Tâches MSBuild	Indique comment créer une unité de code exécutable qui peut être utilisée par MSBuild afin d'exécuter des opérations de génération atomiques.
Conditions MSBuild	Explique comment utiliser l'attribut Condition dans un élément MSBuild.
Concepts avancés de MSBuild	Présente le traitement par lots, l'exécution de transformations, le multi-ciblage, et d'autres techniques avancées.
Journalisation dans MSBuild	Décrit comment enregistrer les événements de build, messages, et des erreurs.
Ressources MSBuild supplémentaires	Répertorie les ressources de communauté et de prise en charge pour des informations supplémentaires sur MSBuild.

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.

Partager via