MSBuildMSBuild

O Mecanismo de Build da MicrosoftMicrosoft Build Engine é uma plataforma para a criação de aplicativos.The Mecanismo de Build da MicrosoftMicrosoft Build Engine is a platform for building applications. Esse mecanismo, que é também conhecido como MSBuild, fornece um esquema XML para um arquivo de projeto que controla como a plataforma de build processa e compila software.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. O Visual Studio usa o MSBuild, mas ele não depende do Visual Studio.Visual Studio uses MSBuild, but it doesn't depend on Visual Studio. Ao invocar o msbuild.exe no seu arquivo de projeto ou solução, você pode organizar e criar produtos em ambientes em que o Visual Studio não está instalado.By invoking msbuild.exe on your project or solution file, you can orchestrate and build products in environments where Visual Studio isn't installed.

O Visual Studio usa o MSBuild para carregar e compilar projetos gerenciados.Visual Studio uses MSBuild to load and build managed projects. Os arquivos de projeto no Visual Studio ( .csproj, .vbproj, .vcxproj e outros) contêm o código XML do MSBuild que é executado ao compilar um projeto usando o 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. Os projetos do Visual Studio importam toas as configurações e processos de build necessários para realizar o trabalho de desenvolvimento típico, mas você pode estendê-las ou modificá-las de dentro do Visual Studio ou usando um editor de 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.

Para obter informações sobre o MSBuild para C++, consulte MSBuild (Visual C++).For information about MSBuild for C++, see MSBuild (Visual C++).

Os exemplos a seguir ilustram quando você deve executar builds usando uma linha de comando do MSBuild em vez do IDE do Visual Studio.The following examples illustrate when you might run builds by using an MSBuild command line instead of the Visual Studio IDE.

  • O Visual Studio não está instalado.Visual Studio isn't installed. (baixar o MSBuild sem o Visual Studio)(download MSBuild without Visual Studio)

  • Você deseja usar a versão de 64 bits do MSBuild.You want to use the 64-bit version of MSBuild. Esta versão do MSBuild normalmente não é necessária, mas permite que o MSBuild acesse mais memória.This version of MSBuild is usually unnecessary, but it allows MSBuild to access more memory.

  • Você deseja executar um build em vários processos.You want to run a build in multiple processes. No entanto, você pode usar o IDE para alcançar o mesmo resultado em projetos em C++ e C#.However, you can use the IDE to achieve the same result on projects in C++ and C#.

  • Você deseja modificar o sistema de build.You want to modify the build system. Por exemplo, você talvez queira habilitar as seguintes ações:For example, you might want to enable the following actions:

    • Pré-processar arquivos antes de eles chegarem ao compilador.Preprocess files before they reach the compiler.

    • Copiar as saídas de build para um local diferente.Copy the build outputs to a different place.

    • Criar arquivos compactados de saídas de build.Create compressed files from build outputs.

    • Realizar uma etapa de pós-processamento.Do a post-processing step. Por exemplo, convém marcar um assembly com uma versão diferente.For example, you might want to stamp an assembly with a different version.

Você pode escrever código no IDE do Visual Studio, mas executar os builds usando o MSBuild.You can write code in the Visual Studio IDE but run builds by using MSBuild. Como outra alternativa, você pode compilar o código no IDE em um computador de desenvolvimento, mas usar uma linha de comando do MSBuild para compilar o código integrado de vários desenvolvedores.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

Você pode usar o Team Foundation Build para compilar, testar e implantar seu aplicativo automaticamente.You can use Team Foundation Build to automatically compile, test, and deploy your application. O sistema de build pode executar builds automaticamente quando os desenvolvedores fazem o check-in de código (por exemplo, como parte de uma estratégia de Integração Contínua) ou de acordo com um cronograma (por exemplo, um build de teste de aceitação pós-build noturno).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). O Team Foundation Build compila seu código usando o MSBuild.Team Foundation Build compiles your code by using MSBuild. Para obter mais informações, confira Azure Pipelines.For more information, see Azure Pipelines.

Este tópico fornece uma visão geral do MSBuild.This topic provides an overview of MSBuild. Para obter um tutorial de introdução, confira Passo a passo: Usando o MSBuild.For an introductory tutorial, see Walkthrough: Using MSBuild.

Usar MSBuild em um prompt de comandoUse MSBuild at a command prompt

Para executar MSBuildMSBuild em um prompt de comando, passe um arquivo de projeto para MSBuild.exe, junto com as opções de linha de comando apropriadas.To run MSBuildMSBuild at a command prompt, pass a project file to MSBuild.exe, together with the appropriate command-line options. As opções de linha de comando permitem que você defina propriedades, execute destinos específicos e defina outras opções que controlam o processo de build.Command-line options let you set properties, execute specific targets, and set other options that control the build process. Por exemplo, você usaria a seguinte sintaxe de linha de comando para criar o arquivo MyProj.proj com a propriedade Configuration definida como 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

Para saber mais sobre opções de linha de comando MSBuildMSBuild, consulte Referência de linha de comando.For more information about MSBuildMSBuild command-line options, see Command-line reference.

Important

Antes de baixar um projeto, determine a confiabilidade do código.Before you download a project, determine the trustworthiness of the code.

Arquivo de projetoProject file

O MSBuildMSBuild usa um formato de arquivo de projeto baseado em XML que é simples e extensível.MSBuildMSBuild uses an XML-based project file format that's straightforward and extensible. O formato de arquivo de projeto do MSBuildMSBuild permite que os desenvolvedores descrevam os itens que devem ser compilados e também como eles devem ser compilados para diferentes sistemas operacionais e configurações.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. Além disso, o formato de arquivo de projeto permite aos desenvolvedores criar regras de build reutilizáveis que podem ser fatoradas em arquivos separados para que os builds possam ser realizados de forma consistente entre os diferentes projetos no produto.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.

As seções a seguir descrevem alguns dos elementos básicos do formato de arquivo de projeto MSBuildMSBuild.The following sections describe some of the basic elements of the MSBuildMSBuild project file format. Para obter um tutorial sobre como criar um arquivo de projeto básico, confira Passo a passo: Criando um arquivo de projeto do MSBuild do zero.For a tutorial about how to create a basic project file, see Walkthrough: Creating an MSBuild project file from scratch.

PropriedadesProperties

As propriedades representam pares chave-valor que podem ser usados para configurar builds.Properties represent key/value pairs that can be used to configure builds. As propriedades são declaradas com a criação de um elemento que tem o nome da propriedade como um filho de um elemento PropertyGroup.Properties are declared by creating an element that has the name of the property as a child of a PropertyGroup element. Por exemplo, o código a seguir cria uma propriedade chamada BuildDir que tem um valor de Build.For example, the following code creates a property named BuildDir that has a value of Build.

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

Você pode definir uma propriedade condicionalmente colocando um atributo Condition no elemento.You can define a property conditionally by placing a Condition attribute in the element. O conteúdo dos elementos condicionais é ignorado a menos que a condição seja avaliada como true.The contents of conditional elements are ignored unless the condition evaluates to true. No exemplo a seguir, o elemento Configuration será definido se ainda não tiver sido definido.In the following example, the Configuration element is defined if it hasn't yet been defined.

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

As propriedades podem ser referenciadas por todo o arquivo de projeto usando a sintaxe $(<PropertyName>).Properties can be referenced throughout the project file by using the syntax $(<PropertyName>). Por exemplo, você pode fazer referência às propriedades nos exemplos anteriores usando $(BuildDir) e $(Configuration).For example, you can reference the properties in the previous examples by using $(BuildDir) and $(Configuration).

Para saber mais sobre propriedades, confira Propriedades do MSBuild.For more information about properties, see MSBuild properties.

ItensItems

Os itens são entradas no sistema de build e normalmente representam arquivos.Items are inputs into the build system and typically represent files. Os itens são agrupados em tipos de item com base em seus nomes de item definidos pelo usuário.Items are grouped into item types, based on user-defined item names. Esses tipos de item podem ser usados como parâmetros para tarefas, que usam os itens individuais para executar as etapas do processo de build.These item types can be used as parameters for tasks, which use the individual items to perform the steps of the build process.

Os itens são declarados no arquivo de projeto, criando um elemento que tem o nome do tipo de item como um filho de um elemento 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. Por exemplo, o código a seguir cria um tipo de item chamado Compile, que inclui dois arquivos.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>

Os tipos de item podem ser referenciados por todo o arquivo de projeto usando a sintaxe @(<ItemType>).Item types can be referenced throughout the project file by using the syntax @(<ItemType>). Por exemplo, o tipo de item no exemplo seria referenciado usando @(Compile).For example, the item type in the example would be referenced by using @(Compile).

No MSBuild, os nomes de elementos e atributos diferenciam maiúsculas de minúsculas.In MSBuild, element and attribute names are case-sensitive. No entanto, os nomes de propriedade, item e metadados não.However, property, item, and metadata names are not. O exemplo a seguir cria o tipo de item Compile, comPile ou qualquer outra variação de maiúsculas e minúsculas e fornece ao tipo de item o valor "one.cs;two.cs".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>

Os itens podem ser declarados usando caracteres curinga e podem conter metadados adicionais para cenários de build mais avançados.Items can be declared by using wildcard characters and may contain additional metadata for more advanced build scenarios. Para obter mais informações sobre os itens, consulte Itens.For more information about items, see Items.

TarefasTasks

As tarefas são unidades de código executável que os projetos MSBuildMSBuild usam para executar operações de build.Tasks are units of executable code that MSBuildMSBuild projects use to perform build operations. Por exemplo, uma tarefa pode compilar os arquivos de entrada ou executar uma ferramenta externa.For example, a task might compile input files or run an external tool. As tarefas podem ser reutilizadas e podem ser compartilhadas por diferentes desenvolvedores em projetos diferentes.Tasks can be reused, and they can be shared by different developers in different projects.

A lógica de execução de uma tarefa é escrita em código gerenciado e mapeada para MSBuildMSBuild usando o elemento UsingTask.The execution logic of a task is written in managed code and mapped to MSBuildMSBuild by using the UsingTask element. Você pode escrever sua própria tarefa por meio da criação de um tipo gerenciado que implementa a interface ITask.You can write your own task by authoring a managed type that implements the ITask interface. Para saber mais sobre como escrever tarefas, consulte Produção de tarefas.For more information about how to write tasks, see Task writing.

MSBuildMSBuild inclui tarefas comuns que você pode modificar para atender às suas necessidades.includes common tasks that you can modify to suit your requirements. Os exemplos são Copy, que copia arquivos, MakeDir, que cria diretórios e Csc, que compila os arquivos de código-fonte do Visual C#.Examples are Copy, which copies files, MakeDir, which creates directories, and Csc, which compiles Visual C# source code files. Para obter uma lista das tarefas disponíveis juntamente com as informações de uso, consulte Referência das tarefas.For a list of available tasks together with usage information, see Task reference.

Uma tarefa é executada em um arquivo de projeto MSBuildMSBuild criando um elemento que tem o nome da tarefa como um filho de um elemento 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. As tarefas normalmente aceitam parâmetros, que são passados como atributos do elemento.Tasks typically accept parameters, which are passed as attributes of the element. As propriedades e itens do MSBuildMSBuild podem ser usados como parâmetros.Both MSBuildMSBuild properties and items can be used as parameters. Por exemplo, o código a seguir chama a tarefa MakeDir e passa para ela o valor da propriedade BuildDir que foi declarada em um exemplo anterior.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>

Para obter mais informações sobre as tarefas, consulte Tarefas.For more information about tasks, see Tasks.

DestinosTargets

Os destinos agrupam tarefas em uma ordem específica e expõe seções do arquivo de projeto como pontos de entrada para o processo de build.Targets group tasks together in a particular order and expose sections of the project file as entry points into the build process. Os destinos geralmente são agrupados em seções lógicas para aumentar a legibilidade e para permitir a expansão.Targets are often grouped into logical sections to increase readability and to allow for expansion. Dividir as etapas de build em destinos permite que você chame uma parte do processo de build de outros destinos sem copiar essa seção do código em cada destino.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. Por exemplo, se vários pontos de entrada no processo de build precisam de referências para serem compilados, você pode criar um destino que compila as referências e, em seguida, executar esse destino de todos os pontos de entrada em que ele é necessário.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.

Os destinos são declarados no arquivo de projeto usando o elemento Target.Targets are declared in the project file by using the Target element. Por exemplo, o código a seguir cria um destino chamado Compile, que, em seguida, chama a tarefa Csc que tem a lista de itens declarada no exemplo anterior.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>

Em cenários mais avançados, os destinos podem ser usados para descrever relações entre si e executar a análise de dependência para que seções inteiras do processo de build possam ser ignoradas se o destino estiver atualizado.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. Para obter mais informações sobre destinos, consulte Destinos.For more information about targets, see Targets.

Logs de buildBuild logs

Você pode registrar erros de build, avisos e mensagens para o console ou outro dispositivo de saída.You can log build errors, warnings, and messages to the console or another output device. Para saber mais, confira Obter logs de build e Registrar em logs no MSBuild.For more information, see Obtaining build logs and Logging in MSBuild.

Usar MSBuild no Visual StudioUse MSBuild in Visual Studio

O Visual StudioVisual Studio usa o formato de arquivo de projeto MSBuildMSBuild para armazenar informações de build sobre projetos gerenciados.Visual StudioVisual Studio uses the MSBuildMSBuild project file format to store build information about managed projects. As configurações do projeto adicionadas ou alteradas usando a interface Visual StudioVisual Studio são refletidas no arquivo .*proj gerado para cada projeto.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. O Visual StudioVisual Studio usa uma instância hospedada do MSBuildMSBuild para compilar projetos gerenciados.Visual StudioVisual Studio uses a hosted instance of MSBuildMSBuild to build managed projects. Isso significa que um projeto gerenciado pode ser criado no Visual StudioVisual Studio ou em um prompt de comando (mesmo se Visual StudioVisual Studio não estiver instalado) e os resultados serão idênticos.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.

Para obter um tutorial sobre como usar o MSBuild no Visual Studio, confira Passo a passo: Usando o MSBuild.For a tutorial about how to use MSBuild in Visual Studio, see Walkthrough: Using MSBuild.

MultiplataformaMultitargeting

Usando o Visual Studio, você pode compilar um aplicativo para ser executado em qualquer uma das várias versões do .NET Framework.By using Visual Studio, you can compile an application to run on any one of several versions of the .NET Framework. Por exemplo, você pode compilar um aplicativo para execução no .NET Framework 2.0 em uma plataforma de 32 bits e pode compilar o mesmo aplicativo para ser executado no .NET Framework 4.5 em uma plataforma de 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. A capacidade de compilar para mais de uma estrutura é chamada de multiplataforma.The ability to compile to more than one framework is named multitargeting.

Estes são alguns dos benefícios de multiplataforma:These are some of the benefits of multitargeting:

  • Você pode desenvolver aplicativos destinados a versões anteriores do .NET Framework, por exemplo, versões 2.0, 3.0 e 3.5.You can develop applications that target earlier versions of the .NET Framework, for example, versions 2.0, 3.0, and 3.5.

  • Você pode direcionar estruturas que não sejam o .NET Framework, por exemplo, o Silverlight.You can target frameworks other than the .NET Framework, for example, Silverlight.

  • Você pode direcionar um perfil de estrutura, que é um subconjunto predefinido de uma estrutura de destino.You can target a framework profile, which is a predefined subset of a target framework.

  • Se um service pack para a versão atual do .NET Framework for lançado, você poderá visá-lo.If a service pack for the current version of the .NET Framework is released, you could target it.

  • A multiplataforma garante que um aplicativo use apenas a funcionalidade que está disponível na estrutura de destino e na plataforma.Multitargeting guarantees that an application uses only the functionality that's available in the target framework and platform.

Para obter mais informações, consulte Multiplataforma.For more information, see Multitargeting.

Consulte tambémSee also

TítuloTitle DESCRIÇÃODescription
Passo a passo: Criando um arquivo de projeto do MSBuild do zeroWalkthrough: Creating an MSBuild project file from scratch Mostra como criar um arquivo de projeto básico de forma incremental, usando somente um editor de texto.Shows how to create a basic project file incrementally, by using only a text editor.
Passo a passo: Usando o MSBuildWalkthrough: Using MSBuild Apresenta os blocos de construção do MSBuild e mostra como escrever, manipular e depurar projetos do MSBuild sem fechar o IDE do Visual Studio.Introduces the building blocks of MSBuild and shows how to write, manipulate, and debug MSBuild projects without closing the Visual Studio IDE.
Conceitos do MSBuildMSBuild concepts Apresenta os quatro blocos de construção do MSBuild: propriedades, itens, destinos e tarefas.Presents the four building blocks of MSBuild: properties, items, targets, and tasks.
ItensItems Descreve os conceitos gerais por trás do formato do arquivo MSBuildMSBuild e como as partes se encaixam.Describes the general concepts behind the MSBuildMSBuild file format and how the pieces fit together.
Propriedades do MSBuildMSBuild properties Introduz propriedades e coleções de propriedades.Introduces properties and property collections. Propriedades são pares chave-valor que podem ser usados para configurar builds.Properties are key/value pairs that can be used to configure builds.
DestinosTargets Explica como agrupar tarefas em uma ordem específica e habilitar seções do processo de build a ser chamado na linha de comando.Explains how to group tasks together in a particular order and enable sections of the build process to be called on the command line.
TarefasTasks Mostra como criar uma unidade do código executável que pode ser usado por MSBuildMSBuild para realizar operações de build atômicas.Shows how to create a unit of executable code that can be used by MSBuildMSBuild to perform atomic build operations.
CondiçõesConditions Discute como usar o atributo Condition em um elemento do MSBuild.Discusses how to use the Condition attribute in an MSBuild element.
Conceitos avançadosAdvanced concepts Apresenta o envio em lote, a execução de transformações, a multiplataforma e outras técnicas avançadas.Presents batching, performing transforms, multitargeting, and other advanced techniques.
Registrando em log no MSBuildLogging in MSBuild Descreve como registrar eventos de build, mensagens e erros.Describes how to log build events, messages, and errors.
Recursos adicionaisAdditional resources Lista os recursos de comunidade e suporte para obter mais informações sobre o MSBuild.Lists community and support resources for more information about MSBuild.

ReferênciaReference