MSBuild
O Mecanismo de compilação Microsoft é uma plataforma para a criação de aplicativos. Esse mecanismo, que também é conhecido como MSBuild, fornece um esquema XML para um arquivo de projeto que controla como a plataforma de compilação processa e compila software. O Visual Studio usa o MSBuild, mas ele não depende de Visual Studio. Invocando msbuild.exe no seu arquivo de projeto ou solução, você pode coordenar e criar produtos em ambientes onde o Visual Studio não está instalado.
Visual Studio usa o MSBuild para carregar e compilar projetos gerenciados. Os arquivos de projeto no Visual Studio (. csproj,. vbproj, vcxproj e outras pessoas) contêm código de XML do MSBuild que é executado quando você compila um projeto usando o IDE. Importar as configurações necessárias de projetos do Visual Studio e criam processos para fazer o trabalho de desenvolvimento típico, mas você pode estender ou modificá-las de dentro do Visual Studio ou usando um editor de XML.
Para obter informações sobre o MSBuild para C++, consulte MSBuild (Visual C++).
Os exemplos a seguir ilustram quando você pode executar compilações usando uma linha de comando do MSBuild em vez de IDE do Visual Studio.
O Visual Studio não está instalado.
Você deseja usar a versão de 64 bits do MSBuild. Esta versão do MSBuild normalmente não é necessário, mas permite que o MSBuild acessar mais memória.
Você deseja executar uma compilação em vários processos. No entanto, você pode usar o IDE para alcançar o mesmo resultado em projetos em C++ e c#.
Você deseja modificar o sistema de compilação. Por exemplo, você talvez queira habilitar as seguintes ações:
Arquivos de pré-processamento antes que elas atinjam o compilador.
Copie as saídas de compilação para um local diferente.
Crie arquivos compactados de saídas de compilação.
Execute uma etapa de pós-processamento. Por exemplo, você talvez queira marcar um assembly com uma versão diferente.
Você pode escrever código no IDE do Visual Studio, mas executar compilações usando o MSBuild. Como outra alternativa, você pode compilar código no IDE em um computador de desenvolvimento, mas usar uma linha de comando do MSBuild para criar código que é integrado de vários desenvolvedores.
Dica
Você pode usar o Team Foundation Build para compilar, testar e implantar seu aplicativo automaticamente.O sistema de compilação pode executar compilações quando os desenvolvedores check-in de 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 de teste de verificação de compilação noturna) automaticamente.O Team Foundation Build para compilar o código usando o MSBuild.Para obter mais informações, consulte Compilar o aplicativo.
Este tópico fornece uma visão geral do MSBuild. Para um tutorial de Introdução, consulte Instruções 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
Multiplataforma
Usando MSBuild em um Prompt de Comando
Para executar MSBuild em um prompt de comando, passe um arquivo de projeto para MSBuild.exe, junto com as opções de linha de comando apropriadas. Opções de linha de comando permitem que você defina propriedades, executar destinos específicos e definir outras opções que controlam o processo de compilação. Por exemplo, você usaria a seguinte sintaxe de linha de comando para criar o arquivo MyProj.proj com o Configuration definida como Debug.
MSBuild.exe MyProj.proj /property:Configuration=Debug
Para obter mais informações sobre MSBuild opções de linha de comando, consulte Referência de linha de comando MSBuild.
.gif "Observação de segurança") Observação de segurança |
|---|
Antes de baixar um projeto, determine a confiabilidade do código. |
Arquivo de Projeto
MSBuildusa um formato de arquivo de projeto com base em XML que é simples e extensível. O MSBuild formato de arquivo de projeto permite que os desenvolvedores descrevem os itens que devem ser criados e também como eles devem ser criados para diferentes sistemas operacionais e configurações. Além disso, o formato de arquivo de projeto permite aos desenvolvedores criar compilação reutilizáveis regras que possam ser fatoradas em arquivos separados, para que as compilações podem ser executadas consistentemente entre diferentes projetos no produto.
As seções a seguir descrevem alguns dos elementos básicos do MSBuild formato de arquivo do projeto. Para obter um tutorial sobre como criar um arquivo de projeto básico, consulte Instruções passo a passo: criando um arquivo de projeto do MSBuild do zero.
Propriedades
Propriedades representam os pares chave/valor que podem ser usados para configurar compilações. Propriedades são declaradas com a criação de um elemento que tem o nome da propriedade como um filho de um PropertyGroup elemento. Por exemplo, o código a seguir cria uma propriedade chamada BuildDir que tem um valor de Build.
<PropertyGroup>
<BuildDir>Build</BuildDir>
</PropertyGroup>
Você pode definir uma propriedade condicionalmente colocando um Condition atributo no elemento. O conteúdo dos elementos condicionais é ignorado, a menos que a condição for avaliada como true. No exemplo a seguir, o Configuration elemento é definido, se ainda não tiver sido definida.
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
Propriedades podem ser referenciadas em todo o arquivo de projeto usando a sintaxe $(PropertyName). Por exemplo, você pode fazer referência às propriedades nos exemplos anteriores usando $(BuildDir) e $(Configuration).
Para obter mais informações sobre propriedades, consulte Propriedades do MSBuild.
Itens
Itens são entradas para o sistema de compilação e geralmente representam arquivos. Itens são agrupadas em tipos de item, com base em nomes de item definido pelo usuário. 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.
Itens são declarados no arquivo de projeto, criando um elemento que tem o nome do tipo de item como um filho de um ItemGroup elemento. 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>
Tipos de item podem ser referenciadas em todo o arquivo de projeto usando a sintaxe @(ItemType). Por exemplo, o tipo de item no exemplo poderia ser referenciado usando @(Compile).
No MSBuild, nomes de elementos e atributos diferenciam maiúsculas de minúsculas. No entanto, os nomes de propriedade, item e metadados não são. O exemplo a seguir cria o tipo de item Compile, comPile, ou qualquer outra variação maiúsculas e retorna o valor "one.cs;two.cs" de tipo de item.
<ItemGroup>
<Compile Include="one.cs" />
<comPile Include="two.cs" />
</ItemGroup>
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 itens, consulte Itens do MSBuild.
Tarefas
As tarefas são unidades de executável de código que MSBuild projetos usam para executar operações de compilação. Por exemplo, uma tarefa pode compilar os arquivos de entrada ou executar uma ferramenta externa. Tarefas podem ser reutilizadas e eles podem ser compartilhados por diferentes desenvolvedores em projetos diferentes.
A lógica de execução de uma tarefa é escrita em código gerenciado e mapeada para MSBuild usando o UsingTask elemento. Você pode escrever sua própria tarefa por meio da criação de um tipo gerenciado que implementa o ITask interface. Para obter mais informações sobre como escrever tarefas, consulte Escrevendo tarefas.
MSBuildinclui tarefas comuns que você pode modificar para atender às suas necessidades. Os exemplos são cópia, 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íveis junto com informações de uso, consulte Referência das tarefas do MSBuild.
Uma tarefa é executada em uma MSBuild arquivo de projeto, criando um elemento que tem o nome da tarefa como um filho de um destino elemento. Tarefas normalmente aceitam parâmetros, que são passados como atributos do elemento. Ambos MSBuild itens e as propriedades que podem ser usados como parâmetros. Por exemplo, o código a seguir chama o MakeDir de tarefa e passa o valor da BuildDir propriedade declarada no exemplo anterior.
<Target Name="MakeBuildDirectory">
<MakeDir Directories="$(BuildDir)" />
</Target>
Para obter mais informações sobre tarefas, consulte Tarefas do MSBuild.
Destinos
Os destinos agrupar tarefas em uma ordem específica e expõem seções do arquivo de projeto como pontos de entrada para o processo de compilação. Destinos geralmente são agrupados em seções lógicas para aumentar a legibilidade e para permitir expansão. Dividir as etapas de compilação em destinos permite que você chame uma parte do processo de compilação de outros destinos sem copiar essa seção do código em cada destino. Por exemplo, se vários pontos de entrada para o processo de compilação exigem referências a ser criado, crie um destino que constrói referências e execute esse destino de cada ponto de entrada em que ele é necessário.
Destinos são declarados no arquivo de projeto usando o destino elemento. Por exemplo, o código a seguir cria um destino chamado Compile, que, em seguida, chama o Csc tarefa com a lista de itens 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 si e executar a análise de dependência para que as seções inteiras do processo de compilação podem ser ignoradas se o destino está atualizado. Para obter mais informações sobre destinos, consulte Destinos do MSBuild.
Compilar Logs
Você pode registrar erros de compilação, avisos e mensagens para o console ou outro dispositivo de saída. Para obter mais informações, consulte Obtendo logs de compilação com o MSBuild e Registrando em logs no MSBuild.
Usando MSBuild no Visual Studio
Visual Studiousa o MSBuild formato de arquivo de projeto para armazenar informações de compilação sobre projetos gerenciados. Configurações que são adicionadas ou alteradas por meio do projeto a Visual Studio interface são refletidas na. * proj arquivo é gerado para cada projeto. Visual Studiousa uma instância hospedada do MSBuild para criar projetos gerenciados. Isso significa que um projeto gerenciado pode ser criado Visual Studio ou em um prompt de comando (mesmo se Visual Studio não estiver instalado), e os resultados serão idênticos.
Para obter um tutorial sobre como usar o MSBuild no Visual Studio, consulte Instruções passo a passo: usando o MSBuild.
Multiplataforma
Usando o Visual Studio, você pode compilar um aplicativo para execução em qualquer uma das várias versões do .NET Framework. Por exemplo, você pode compilar um aplicativo para execução no .NET Framework 2.0 em uma plataforma de 32 bits, e você pode compilar o mesmo aplicativo para execução no .NET Framework 4.5 em uma plataforma de 64 bits. A capacidade de compilar a mais de uma estrutura é denominada multiplataforma.
Estes são alguns dos benefícios de multiplataforma:
Você pode desenvolver aplicativos destinados a versões anteriores do .NET Framework, por exemplo, as versões 2.0, 3.0 e 3.5.
Você pode direcionar estruturas diferentes do .NET Framework, por exemplo, o Silverlight.
Você pode direcionar um perfil do framework, que é um subconjunto de uma estrutura de destino predefinido.
Se um service pack para a versão atual do .NET Framework é liberado, você poderá concentrá-lo.
Multitargeting garante que um aplicativo usa apenas a funcionalidade que está disponível no framework de destino e plataforma.
Para obter mais informações, consulte Visão geral da multiplataforma no MSBuild.
Tópicos relacionados
Título |
Descrição |
|---|---|
Instruções passo a passo: criando um arquivo de projeto do MSBuild do zero |
Mostra como criar um arquivo de projeto básico incrementalmente, usando apenas um texto editor. |
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. |
|
Apresenta os quatro blocos de construção do MSBuild: propriedades, itens, destinos e tarefas. |
|
Descreve os conceitos gerais de MSBuild de arquivos de formato e como as peças se encaixam. |
|
Apresenta propriedades e coleções de propriedade. As propriedades são pares chave/valor que podem ser usados para configurar compilações. |
|
Explica como agrupar tarefas juntos em uma ordem específica e habilitar seções do processo de compilação a ser chamado na linha de comando. |
|
Mostra como criar uma unidade de código executável que pode ser usado por MSBuild para executar operações atômicas de compilação. |
|
Discute como usar o Condition atributo em um elemento do MSBuild. |
|
Apresenta o envio em lote, executar transformações, multiplataforma e outras técnicas avançadas. |
|
Descreve como registrar eventos de compilação, mensagens e erros. |
|
Lista os recursos de comunidade e suporte para obter mais informações sobre o MSBuild. |
Referência
Referência do MSBuild
Links para tópicos que contêm informações de referência.Glossário do MSBuild
Define termos comuns do MSBuild.