MSBuild

Mecanismo de compilação Microsoft é uma plataforma para criar aplicativos.Esse mecanismo, que é também conhecido como MSBuild, fornece um esquema XML para um arquivo de projeto que controle como a plataforma de compilação processamento e compila o software.O Visual Studio usa MSBuild, mas ele não depende do Visual Studio. Invocando msbuild.exe em seu projeto ou arquivo de solução, você pode orquestrar e criar classes em ambientes onde o Visual Studio não está instalado.

O Visual Studio usa MSBuild para carregar e criar projetos gerenciados.Os arquivos de projeto no Visual Studio (.csproj, .vbproj, vcxproj, e outro) contêm o código do MSBuild XML que executa quando você cria um projeto usando o IDE.Os projetos do Visual Studio é importante todas as configurações e processos de compilação necessários para fazer o trabalho de desenvolvimento típico, mas você pode alterar estender-los ou de dentro do Visual Studio ou usando um editor XML.

Os exemplos a seguir ilustram quando você pode executar compilações usando uma linha de comando MSBuild em vez do IDE do Visual Studio.

• Visual Studio não está instalado.

• Você deseja usar a versão de 64 bits do MSBuild.Esta versão do MSBuild geralmente é desnecessária, mas permite que acessa MSBuild mais memória.

• Você desejar executar uma compilação em vários processos.No entanto, você pode usar o IDE para obter o mesmo resultado em projetos em C++ e, começando com Visual Studio 2012, C#.

• Você deseja alterar o sistema de compilação.Por exemplo, talvez queira ativar as seguintes ações:

  • Preprocessa arquivos antes que elas atinjam o compilador.

  • Copiar a saída de compilação para um local diferente.

  • Crie arquivos compactados de saída de compilação.

  • Execute uma etapa de pré processamento.Por exemplo, convém carimbar um assembly com uma versão diferente.

Você pode escrever código em Visual Studio IDE mas executar compilações usando MSBuild.Como outra alternativa, você pode compilar o código no IDE em um computador de desenvolvimento mas usar uma linha de comando MSBuild para compilar o código que está integrado de vários desenvolvedores.

Observação

Você pode usar o team foundation build para criar, teste, e implantar o aplicativo automaticamente.Seu sistema de compilação pode executar compilações automaticamente quando os desenvolvedores fazer o check-in no código (por exemplo, como parte de uma estratégia de integração contínua) ou de acordo com uma agenda (por exemplo, uma compilação nocturna de teste de verificação de compilação).O team foundation build compila o código usando MSBuild.Para obter mais informações, consulte Construção do aplicativo.

Este tópico fornece uma visão geral do MSBuild.Para um tutorial de introdução, consulte Passo a passo: Usando o MSBuild.

Neste tópico

• Usando MSBuild em um prompt de comando

• Arquivo de projeto

  • Propriedades

  • Itens

  • Tarefas

  • Destinos

• Compilar logs

• Usando MSBuild no Visual Studio

• Multitargeting

Usando MSBuild em um prompt de comando

Para executar MSBuild em um prompt de comando, passe um arquivo de projeto a MSBuild.exe, junto com as opções de linha de comando apropriado.As opções de linha de comando permitem propriedades definidas, as executa em destinos específicos, e definir outras opções que controlam o processo de compilação.Por exemplo, você usa a seguinte sintaxe de linha de comando para criar o arquivo MyProj.proj com a propriedade de Configuration definida como Debug.

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

Para obter mais informações sobre as opções de linha de comando MSBuild , consulte Referência de linha de comando MSBuild. 

Observação de segurança
Antes que você baixa um projeto, determine a confiabilidade do código.

Arquivo de projeto

MSBuild usa um formato de arquivo baseado em XML de projeto que é simples e extensível.O formato de arquivo de projeto de MSBuild permite que desenvolvedores descrever itens que devem ser compilados, e também como eles devem ser compilados para sistemas operacionais e configurações diferentes.Além disso, o formato de arquivo de projeto permite que desenvolvedores criar regras reutilizáveis de compilação que podem ser fatoradas em arquivos separados de modo que as compilações podem ser executadas consistentemente entre os projetos diferentes no produto.

As seções a seguir descrevem alguns dos elementos básicos de formato de arquivo de projeto de MSBuild . Para um tutorial sobre como criar um arquivo de projeto básico, consulte Passo a passo: Criando um arquivo de projeto MSBuild a partir do zero.

Propriedades

As propriedades representam os pares chave/valor que podem ser usados para configurar compilações.As propriedades são declaradas criando um elemento que tem o nome da propriedade como um filho de um elemento de PropertyGroup .Por exemplo, o código a seguir cria uma propriedade chamada BuildDir que tenha um valor de Build.

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

Você pode definir uma propriedade condicional colocando um atributo de Condition no elemento.O conteúdo dos elementos condicionais são ignorados a menos que a condição avaliar a true.No exemplo a seguir, o elemento de Configuration é definido se ainda não foi definido.

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

As propriedades podem ser referenciadas em todo o arquivo de projeto usando a sintaxe $ (PropertyName).Por exemplo, você pode referenciar as propriedades nos exemplos anteriores usando $(BuildDir) e $(Configuration).

Para obter mais informações sobre propriedades, consulte Propriedades do MSBuild.

Itens

Os itens são entradas no sistema de compilação e representam normalmente arquivos.Os itens são agrupados em tipos de item, com base em nomes definidos pelo usuário do item.Esses tipos de item podem ser usados como parâmetros para tarefas, que usam os itens individuais para executar as etapas do processo de compilação.

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 de ItemGroup .Por exemplo, o código a seguir cria um tipo de item chamado Compile, que inclui dois arquivos.

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

Os tipos de item podem ser referenciados em todo o arquivo de projeto usando a sintaxe @ (ItemType).Por exemplo, o tipo de item no exemplo seria referenciado usando @(Compile).

Em MSBuild, os nomes de elementos e atributos diferenciam maiúsculas de minúsculas.No entanto, a propriedade, o item, e os nomes dos metadados não são.O exemplo a seguir cria o tipo de item Compile, comPile, ou qualquer outra variação dos casos, e fornece o tipo de item one.cs o valor “; 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 mais avançados de compilação.Para obter mais informações sobre os itens, consulte Itens do MSBuild.

Tarefas

As tarefas são as unidades de código executável que uso de projetos de MSBuild executar operações de compilação.Por exemplo, uma tarefa pode compilar arquivos de entrada ou executar uma ferramenta externa.As tarefas podem ser reutilizadas, e podem ser compartilhados por diferentes desenvolvedores em projetos diferentes.

A lógica de execução de uma tarefa são escritos em código gerenciado e mapeada para MSBuild usando o elemento de UsingTask .Você pode escrever sua própria tarefa criando um tipo gerenciado que implementa a interface de ITask .Para obter mais informações sobre como escrever tarefas, consulte Escrita de tarefa.

MSBuild inclui as tarefas comuns que você pode alterar para atender suas necessidades.Exemplos são Impressão, que copia arquivos, MakeDir, que cria pastas, e Csc, que compila arquivos de código-fonte Visual c#.Para obter uma lista de tarefas disponível junto com informações de uso, consulte Referência de tarefa do MSBuild.

Uma tarefa é executada em um arquivo de projeto de MSBuild criando um elemento que tem o nome da tarefa como um filho de um elemento de Destino .As tarefas normalmente aceitam parâmetros, que são passados como atributos do elemento.As propriedades e os itens de MSBuild podem ser usados como parâmetros.Por exemplo, o código a seguir chama a tarefa de MakeDir e passe o valor da propriedade de BuildDir que foi declarada no exemplo anterior.

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

Para obter mais informações sobre as tarefas, consulte Tarefas do MSBuild.

Destinos

Tarefas do grupo de destinos juntos em uma ordem específica e em seções de exposição do arquivo de projeto como pontos de entrada no processo de compilação.Destinos são frequentemente agrupados em seções lógicas para aumentar a legibilidade e para permiti-la a expansão.Quebrar as etapas de compilação em destinos permite que você chamar uma parte do processo de compilação de outros destinos sem cópia essa seção de código em cada destino.Por exemplo, se vários pontos de entrada no processo de compilação exigem referências ser compilados, você pode criar um destino que referências compile e execute o destino de cada ponto de entrada onde necessária.

Destinos são declarados no arquivo de projeto usando o elemento de Destino .Por exemplo, o código a seguir cria um alvo nomeado Compile, que chama a tarefa de Csc que tem a lista de item que foi declarada no exemplo anterior.

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

Em cenários mais avançados, destinos podem ser usados para descrever relações entre uma outras e executar a análise de dependência de modo que as seções inteiras do processo de compilação possam ser ignoradas se o destino é atualizado.Para obter mais informações sobre destinos, consulte Destinos do MSBuild.

Compilar logs

Você pode registrar erros, avisos e mensagens de compilação para o console ou outro dispositivo de saída.Para obter mais informações, consulte Obtendo logs de compilação com o MSBuild e Efetuando login MSBuild.

Usando MSBuild no Visual Studio

Visual Studio usa o formato de arquivo de projeto de MSBuild para armazenar informações de compilação sobre projetos gerenciados.Configurações do projeto que são adicionadas ou alterado usando a interface de Visual Studio são refletidos no. arquivo de *proj que é gerado para cada projeto.Visual Studio usa uma instância de MSBuild hospedado para criar projetos gerenciados.Isso significa que um projeto gerenciado pode ser Visual Studio interna ou em um prompt de comando (mesmo se Visual Studio não é instalado), e os resultados serão idênticos.

Para um tutorial sobre como usar MSBuild no Visual Studio, consulte Passo a passo: Usando o MSBuild.

Multitargeting

Usando o Visual Studio, você pode compilar um aplicativo executar em qualquer uma das várias versões do .NET Framework.Por exemplo, você pode compilar um aplicativo execute no.NET Framework 2,0 em uma plataforma de 32 bits, e você pode compilar o mesmo aplicativo execute no.NET Framework 4.5 em uma plataforma de 64 bits.A capacidade de criar a mais de uma estrutura é chamada multitargeting.

Estes são alguns dos benefícios do multitargeting:

• Você pode desenvolver aplicativos que usam versões anteriores do.NET Framework, por exemplo, para versões 2,0, 3,0, e 3,5.

• Você pode direcionar frameworks do.NET Framework, por exemplo, o Silverlight.

• Você pode direcionar um perfil de estrutura, que é um subconjunto predefinido de uma estrutura de destino.

• Se um serviço de empacotamento para a versão atual do.NET Framework é solto, você pode destinar-lo.

• Multitargeting garante que um aplicativo usa apenas funcionalidade que está disponível na estrutura e na plataforma de destino.

Para obter mais informações, consulte Visão geral do MSBuild Multitargeting.

Tópicos relacionados

Nome	Descrição
Passo a passo: Criando um arquivo de projeto MSBuild a partir do zero	Mostra como criar incremental um arquivo de projeto básico, usando apenas um editor de texto.
Passo a passo: Usando o MSBuild	Apresenta os blocos de construção de MSBuild e mostra como escrever, manipular, e depurar de projetos MSBuild sem fechar o IDE do Visual Studio.
Conceitos do MSBuild	Apresenta os quatro blocos de construção de MSBuild: propriedades, itens, destinos, e tarefas.
Itens do MSBuild	Descreve os conceitos gerais code-behind de formato de arquivo de MSBuild e como as partes cabem juntos.
Propriedades do MSBuild	Apresenta propriedades e coleções de propriedade.As propriedades são pares chave/valor que podem ser usados para configurar compilações.
Destinos do MSBuild	Explica como agrupar tarefas em uma ordem específica e ativar seções do processo de compilação a ser chamado a linha de comando.
Tarefas do MSBuild	Mostra como criar uma unidade de código executável que pode ser usada por MSBuild para executar operações atômicas de compilação.
Condições do MSBuild	Descreve como usar o atributo de Condition em um elemento do MSBuild.
MSBuild avançados conceitos	Apresenta os que processam em lotes, executando tornam-se, multitargeting, e outras técnicas avançadas.
Efetuando login MSBuild	Descreve como registrar eventos, mensagens, e erros de compilação.
Recursos adicionais do MSBuild	Listas a comunidade e recursos de suporte para obter mais informações sobre em MSBuild.

Referência

• Referência do MSBuild
  Contém links para tópicos que contém informações de referência.

• Glossário do MSBuild
  Define termos comuns de MSBuild.