MSBuildMSBuild

Le Microsoft Build EngineMicrosoft Build Engine est une plateforme de génération d'applications.The Microsoft Build EngineMicrosoft Build Engine is a platform for building applications. Ce 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 les logiciels.This engine, which is also known as MSBuild, provides an XML schema for a project file that controls how the build platform processes and builds software. Visual Studio utilise MSBuild, mais il ne dépend pas de Visual Studio.Visual Studio uses MSBuild, but it doesn't depend on Visual Studio. En appelant msbuild.exe sur votre fichier projet ou solution, vous pouvez gérer et générer des produits dans des environnements où Visual Studio n’est pas installé.By invoking msbuild.exe on your project or solution file, you can orchestrate and build products in environments where Visual Studio isn't installed.

Visual Studio utilise MSBuild pour charger et générer des projets managés.Visual Studio uses MSBuild to load and build managed projects. Les fichiers projet de Visual Studio (.csproj, .vbproj, .vcxproj et autres) contiennent du code XML MSBuild qui s’exécute lors de la génération d’un projet avec l’environnement IDE.The project files in Visual Studio (.csproj, .vbproj, .vcxproj, and others) contain MSBuild XML code that executes when you build a project by using the 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 développer ou les modifier à partir de Visual Studio ou en utilisant un éditeur XML.Visual Studio projects import all the necessary settings and build processes to do typical development work, but you can extend or modify them from within Visual Studio or by using an XML editor.

Pour plus d’informations sur MSBuild pour C++, consultez MSBuild (Visual C++).For information about MSBuild for C++, see MSBuild (Visual C++).

Les exemples suivants illustrent les cas où vous pouvez exécuter des builds à l'aide d'une ligne de commande MSBuild au lieu de l'IDE de Visual Studio.The following examples illustrate when you might run builds by using an MSBuild command line instead of the Visual Studio IDE.

  • Visual Studio n'est pas installé.Visual Studio isn't installed.

  • Vous souhaitez utiliser la version 64 bits de MSBuild.You want to use the 64-bit version of MSBuild. Cette version MSBuild est généralement inutile, mais elle permet à MSBuild d'accéder à plus de mémoire.This version of MSBuild is usually unnecessary, but it allows MSBuild to access more memory.

  • Vous souhaitez exécuter une build dans plusieurs processus.You want to run a build in multiple processes. Toutefois, vous pouvez utiliser l'IDE pour obtenir le même résultat sur les projets dans C++ et C#.However, you can use the IDE to achieve the same result on projects in C++ and C#.

  • Vous souhaitez modifier le système de génération.You want to modify the build system. Par exemple, vous pouvez souhaiter effectuer les actions suivantes :For example, you might want to enable the following actions:

    • Prétraitez les fichiers avant qu'ils n'atteignent le compilateur.Preprocess files before they reach the compiler.

    • Copiez les sorties de génération à un autre emplacement.Copy the build outputs to a different place.

    • Créez des fichiers compressés à partir des sorties de génération.Create compressed files from build outputs.

    • Procédez à une étape de post-traitement.Do a post-processing step. Par exemple, vous pouvez souhaiter horodater un assembly avec une version différente.For example, you might want to stamp an assembly with a different version.

Vous pouvez écrire du code dans l'IDE de Visual Studio, mais les générations s'exécutent à l'aide de MSBuild.You can write code in the Visual Studio IDE but run builds by using MSBuild. 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 du code qui est intégré par plusieurs développeurs.As another alternative, you can build code in the IDE on a development computer but use an MSBuild command line to build code that's integrated from multiple developers.

Note

Vous pouvez utiliser Team Foundation Build automatiquement pour compiler, tester, puis déployer votre application.You can use Team Foundation Build to automatically compile, test, and deploy your application. Votre système de génération peut automatiquement exécuter des générations lorsque les développeurs archivent du code (par exemple, dans le cadre d'une stratégie continue d'intégration) ou selon une planification (par exemple, une build nocturne de test de vérification de build).Your build system can automatically run builds when developers check in code (for example, as part of a Continuous Integration strategy) or according to a schedule (for example, a nightly Build Verification Test build). Team Foundation Build compile votre code à l’aide de MSBuild.Team Foundation Build compiles your code by using MSBuild. Pour plus d’informations, consultez Azure Pipelines.For more information, see Azure Pipelines.

Cette rubrique fournit une vue d'ensemble de MSBuild.This topic provides an overview of MSBuild. Pour un didacticiel d’introduction, consultez la Procédure pas à pas : utilisation de MSBuild.For an introductory tutorial, see Walkthrough: Using MSBuild.

Utiliser MSBuild dans une invite de commandesUse MSBuild at a command prompt

Pour exécuter MSBuildMSBuild dans une invite de commandes, transmettez un fichier projet à MSBuild.exe, avec les options de ligne de commande appropriées.To run MSBuildMSBuild at a command prompt, pass a project file to MSBuild.exe, together with the appropriate command-line options. 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.Command-line options let you set properties, execute specific targets, and set other options that control the build process. Par exemple, la syntaxe de ligne de commande suivante permet de générer le fichier MyProj.proj avec la propriété Configuration définie sur Debug.For example, you would use the following command-line syntax to build the file MyProj.proj with the Configuration property set to Debug.

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

Pour plus d’informations sur les options de ligne de commande MSBuildMSBuild, voir Informations de référence sur la ligne de commande.For more information about MSBuildMSBuild command-line options, see Command-line reference.

Important

Avant de télécharger un projet, déterminez la crédibilité du code.Before you download a project, determine the trustworthiness of the code.

Fichier projetProject file

MSBuildMSBuild utilise un format de fichier projet XML qui est simple et extensible. uses an XML-based project file format that's straightforward and extensible. Le format du fichier projet MSBuildMSBuild 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.The MSBuildMSBuild project file format lets developers describe the items that are to be built, and also how they are to be built for different operating systems and 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.In addition, the project file format lets developers author reusable build rules that can be factored into separate files so that builds can be performed consistently across different projects in the product.

Les sections suivantes décrivent certains éléments de base du format de fichier projet MSBuildMSBuild.The following sections describe some of the basic elements of the MSBuildMSBuild project file format. Pour suivre un tutoriel sur la création d’un fichier projet de base, voir Procédure pas à pas : Créer un fichier projet MSBuild à partir de zéro.For a tutorial about how to create a basic project file, see Walkthrough: Creating an MSBuild project file from scratch.

PropriétésProperties

Les propriétés sont des paires clé/valeur qui peuvent être utilisées pour configurer les générations.Properties represent key/value pairs that can be used to configure builds. 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.Properties are declared by creating an element that has the name of the property as a child of a PropertyGroup element. Par exemple, le code suivant crée une propriété nommée BuildDir avec la valeur Build.For example, the following code creates a property named BuildDir that has a value of Build.

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

Vous pouvez définir une propriété conditionnellement en plaçant un attribut Condition dans l'élément.You can define a property conditionally by placing a Condition attribute in the element. Le contenu des éléments conditionnels est ignoré, à moins que la condition ait la valeur true.The contents of conditional elements are ignored unless the condition evaluates to true. Dans l'exemple suivant, l'élément Configuration est défini s'il n'a pas encore été défini.In the following example, the Configuration element is defined if it hasn't yet been defined.

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

L’ensemble du fichier projet peut comporter des références à des propriétés suivant la syntaxe $(<nom_propriété>).Properties can be referenced throughout the project file by using the syntax $(<PropertyName>). Par exemple, vous pouvez référencer les propriétés dans les exemples précédents en utilisant $(BuildDir) et $(Configuration).For example, you can reference the properties in the previous examples by using $(BuildDir) and $(Configuration).

Pour plus d’informations sur les propriétés, consultez Propriétés MSBuild.For more information about properties, see MSBuild properties.

ÉlémentsItems

Les éléments sont des entrées du système de génération qui représentent généralement des fichiers.Items are inputs into the build system and typically represent files. Les éléments sont groupés dans différents types d'élément, selon leurs noms d'élément définis par l'utilisateur.Items are grouped into item types, based on user-defined item names. 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.These item types can be used as parameters for tasks, which use the individual items to perform the steps of the build process.

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.Items are declared in the project file by creating an element that has the name of the item type as a child of an ItemGroup element. Par exemple, le code suivant crée un type d'élément nommé Compile et composé de deux fichiers.For example, the following code creates an item type named Compile, which includes two files.

<ItemGroup>
    <Compile Include = "file1.cs"/>
    <Compile Include = "file2.cs"/>
</ItemGroup>

L’ensemble du fichier projet peut comporter des références à des types d’éléments suivant la syntaxe @(<type_élément>).Item types can be referenced throughout the project file by using the syntax @(<ItemType>). Par exemple, le type d'élément dans l'exemple serait référencé avec la syntaxe @(Compile).For example, the item type in the example would be referenced by using @(Compile).

Dans MSBuild, les noms d'éléments et des attributs respectent la casse.In MSBuild, element and attribute names are case-sensitive. En revanche, ce n'est pas le cas pour les noms de propriétés, d'items et de métadonnées.However, property, item, and metadata names are not. L'exemple suivant 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 » est affectée au type d'item.The following example creates the item type Compile, comPile, or any other case variation, and gives the item type the value "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.Items can be declared by using wildcard characters and may contain additional metadata for more advanced build scenarios. Pour plus d’informations sur les éléments, consultez l’article Éléments MSBuild.For more information about items, see Items.

TâchesTasks

Les tâches sont des unités de code exécutable auxquelles les projets MSBuildMSBuild ont recours pour exécuter des opérations de génération.Tasks are units of executable code that MSBuildMSBuild projects use to perform build operations. Par exemple, une tâche peut compiler des fichiers d'entrée ou exécuter un outil externe.For example, a task might compile input files or run an external tool. Les tâches peuvent être réutilisées et partagées par plusieurs développeurs dans différents projets.Tasks can be reused, and they can be shared by different developers in different projects.

La logique d’exécution d’une tâche est écrite en code managé et mappée à MSBuildMSBuild avec l’élément UsingTask.The execution logic of a task is written in managed code and mapped to MSBuildMSBuild by using the UsingTask element. Vous pouvez écrire votre propre tâche en créant un type managé qui implémente l'interface ITask.You can write your own task by authoring a managed type that implements the ITask interface. Pour plus d’informations sur l’écriture de tâches, voir Écriture de tâches.For more information about how to write tasks, see Task writing.

MSBuildMSBuild inclut des tâches communes que vous pouvez modifier pour les adapter à vos spécifications. includes common tasks that you can modify to suit your requirements. Voici des exemples : Copy, qui copie des fichiers, MakeDir, qui crée des répertoires et Csc, qui compile des fichiers de code source Visual C#.Examples are Copy, which copies files, MakeDir, which creates directories, and Csc, which compiles Visual C# source code files. Pour connaître la liste des tâches disponibles et obtenir des informations sur leur utilisation, voir Informations de référence sur les tâches.For a list of available tasks together with usage information, see Task reference.

Une tâche est exécutée dans un fichier projet MSBuildMSBuild en créant un élément avec le nom de la tâche comme enfant d’un élément Target.A task is executed in an MSBuildMSBuild project file by creating an element that has the name of the task as a child of a Target element. En général, les tâches acceptent les paramètres passés comme des attributs de l’élément.Tasks typically accept parameters, which are passed as attributes of the element. Les propriétés et les éléments MSBuildMSBuild peuvent être utilisés comme des paramètres.Both MSBuildMSBuild properties and items can be used as parameters. Par exemple, le code suivant appelle la tâche MakeDir et lui transmet la valeur de la propriété BuildDir déclarée dans l’exemple précédent.For example, the following code calls the MakeDir task and passes it the value of the BuildDir property that was declared in the earlier example.

<Target Name="MakeBuildDirectory">
    <MakeDir  Directories="$(BuildDir)" />
</Target>

Pour plus d’informations sur les tâches, consultez l’article Tâches MSBuild.For more information about tasks, see Tasks.

CiblesTargets

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.Targets group tasks together in a particular order and expose sections of the project file as entry points into the build process. Les cibles sont souvent groupées en sections logiques afin d'accroître la lisibilité et de permettre une expansion.Targets are often grouped into logical sections to increase readability and to allow for 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.Breaking the build steps into targets lets you call one piece of the build process from other targets without copying that section of code into every target. 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.For example, if several entry points into the build process require references to be built, you can create a target that builds references and then run that target from every entry point where it's required.

Les cibles sont déclarées dans le fichier projet avec l’élément Target.Targets are declared in the project file by using the Target element. 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.For example, the following code creates a target named Compile, which then calls the Csc task that has the item list that was declared in the earlier example.

<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.In more advanced scenarios, targets can be used to describe relationships among one another and perform dependency analysis so that whole sections of the build process can be skipped if that target is up-to-date. Pour plus d’informations sur les cibles, consultez l’article Targets (Cibles MSBuild).For more information about targets, see Targets.

Journaux de générationBuild logs

Vous pouvez consigner les erreurs de build, les avertissements et les messages dans la console ou un autre périphérique de sortie.You can log build errors, warnings, and messages to the console or another output device. Pour plus d’informations, voir Obtenir des journaux de génération et Journalisation dans MSBuild.For more information, see Obtaining build logs and Logging in MSBuild.

Utiliser MSBuild dans Visual StudioUse MSBuild in Visual Studio

Visual StudioVisual Studio utilise le format de fichier projet MSBuildMSBuild pour stocker les informations de génération des projets managés. uses the MSBuildMSBuild project file format to store build information about managed projects. Les paramètres de projet ajoutés ou modifiés à l’aide de l’interface Visual StudioVisual Studio sont répercutés dans le fichier .*proj généré pour chaque projet.Project settings that are added or changed by using the Visual StudioVisual Studio interface are reflected in the .*proj file that's generated for every project. Visual StudioVisual Studio utilise une instance hébergée de MSBuildMSBuild pour générer des projets managés. uses a hosted instance of MSBuildMSBuild to build managed projects. Cela signifie qu’un projet managé peut être généré dans Visual StudioVisual Studio ou à partir d’une invite de commandes (même si Visual StudioVisual Studio n’est pas installé) ; les résultats seront identiques.This means that a managed project can be built in Visual StudioVisual Studio or at a command prompt (even if Visual StudioVisual Studio isn't installed), and the results will be identical.

Pour suivre un didacticiel sur l’utilisation de MSBuild dans Visual Studio, consultez la Procédure pas à pas : utilisation de MSBuild.For a tutorial about how to use MSBuild in Visual Studio, see Walkthrough: Using MSBuild.

MulticiblageMultitargeting

Visual Studio vous permet de compiler une application pour l'exécuter sur n'importe quelle version du .NET Framework.By using Visual Studio, you can compile an application to run on any one of several versions of the .NET Framework. Par exemple, vous pouvez compiler une application qui s'exécutera sur le .NET Framework version 2.0 sur une plateforme 32 bits, et vous pouvez compiler la même application pour qu'elle s'exécute sur le .NET Framework version 4.5 sur une plateforme 64 bits.For example, you can compile an application to run on the .NET Framework 2.0 on a 32-bit platform, and you can compile the same application to run on the .NET Framework 4.5 on a 64-bit platform. Le multi-ciblage désigne la possibilité de compiler en plusieurs Frameworks.The ability to compile to more than one framework is named multitargeting.

Voici une partie des avantages offerts par le multi-ciblage :These are some of the benefits of multitargeting:

  • 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).You can develop applications that target earlier versions of the .NET Framework, for example, versions 2.0, 3.0, and 3.5.

  • Vous pouvez cibler des Frameworks autres que le .NET Framework (par exemple, Silverlight).You can target frameworks other than the .NET Framework, for example, Silverlight.

  • Vous pouvez cibler un profil Framework, qui est un sous-ensemble prédéfini d’une version cible de .NET Framework.You can target a framework profile, which is a predefined subset of a target framework.

  • Si un service pack pour la version actuelle du .NET Framework est publié, vous pouvez le cibler.If a service pack for the current version of the .NET Framework is released, you could target it.

  • Le multi-ciblage garantit qu'une application utilise uniquement les fonctionnalités qui sont disponibles dans le framework et la plateforme cibles.Multitargeting guarantees that an application uses only the functionality that's available in the target framework and platform.

Pour plus d’informations, consultez l’article Multiciblage de MSBuild.For more information, see Multitargeting.

Voir aussiSee also

TitreTitle DescriptionDescription
Procédure pas à pas : création d’un fichier projet MSBuild en partant de zéroWalkthrough: Creating an MSBuild project file from scratch Indique comment créer de façon incrémentielle un fichier projet de base, en utilisant uniquement un éditeur de texte.Shows how to create a basic project file incrementally, by using only a text editor.
Procédure pas à pas : utilisation de MSBuildWalkthrough: Using MSBuild Présente les composantes de MSBuild et indique comment écrire, manipuler et déboguer des projets MSBuild sans fermer l'IDE de Visual Studio.Introduces the building blocks of MSBuild and shows how to write, manipulate, and debug MSBuild projects without closing the Visual Studio IDE.
Concepts MSBuildMSBuild concepts Présente les quatre composantes de MSBuild : propriétés, éléments, cibles et tâches.Presents the four building blocks of MSBuild: properties, items, targets, and tasks.
ÉlémentsItems Décrit les concepts généraux sous-jacents au format de fichier MSBuildMSBuild et la manière dont les éléments s'ajustent les uns aux autres.Describes the general concepts behind the MSBuildMSBuild file format and how the pieces fit together.
Propriétés MSBuildMSBuild properties Présente les propriétés et les collections de propriétés.Introduces properties and property collections. Les propriétés sont des paires clé/valeur qui peuvent être utilisées pour configurer les générations.Properties are key/value pairs that can be used to configure builds.
CiblesTargets 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.Explains how to group tasks together in a particular order and enable sections of the build process to be called on the command line.
TâchesTasks Indique comment créer une unité de code exécutable qui peut être utilisée par MSBuildMSBuild afin d'exécuter des opérations de génération atomiques.Shows how to create a unit of executable code that can be used by MSBuildMSBuild to perform atomic build operations.
Conditions MSBuildConditions Explique comment utiliser l'attribut Condition dans un élément MSBuild.Discusses how to use the Condition attribute in an MSBuild element.
Concepts avancésAdvanced concepts Présente le traitement par lot, l'exécution de transformations, le multiciblage, ainsi que d'autres techniques avancées.Presents batching, performing transforms, multitargeting, and other advanced techniques.
Journalisation dans MSBuildLogging in MSBuild Décrit comment consigner des événements, des messages et des erreurs de build.Describes how to log build events, messages, and errors.
Ressources supplémentairesAdditional resources Répertorie les ressources de communauté et de prise en charge pour des informations supplémentaires sur MSBuild.Lists community and support resources for more information about MSBuild.

RéférenceReference

Informations de référence sur MSBuild Liens vers des rubriques contenant les informations de référence.MSBuild reference Links to topics that contain reference information.

Glossaire Définit les termes courants utilisés dans MSBuild.Glossary Defines common MSBuild terms.