Share via

Controlar onde o sistema de compilação coloca seus binários

  • Artigo

Processo de compilação padrão (conforme definido na DefaultTemplate.xaml), descarta os binários que ele compila de todos os seus projetos de código em um único diretório. No entanto, em alguns casos, você deseja organizar os binários em uma estrutura de pasta mais granulares e organizada.

Você pode usar as técnicas neste tópico para criar um processo de compilação personalizada que descarta seus binários em uma estrutura de diretório que você projeta. Você também pode personalizar os processos de construção de maneiras diferentes, usando os mesmos princípios. Este tópico explica as seguintes técnicas:

  • Personalize o segmento do processo de compilação de fluxo de trabalho do Windows. Você deve fazer alterações neste segmento para personalizar a maioria dos aspectos do processo de compilação, exceto para compilação e o tratamento dos binários. Especificamente, este tópico descreve como realizar as seguintes tarefas:

    • Criar um processo de compilação personalizada modificando uma cópia do modelo padrão (DefaultTemplate.xaml).

    • Declarar e usar os argumentos para passar dados no fluxo de trabalho.

    • Declarar e usar variáveis para coletar e transmitir dados em todo o fluxo de trabalho.

    • Modificar como o fluxo de trabalho usa o MSBuild a atividade de chamar MSBuild.

    • Baixar um arquivo para o servidor de compilação e usar o ConvertWorkspaceItem a atividade para tornar o arquivo disponível para o processo de compilação.

  • Personalizar o MSBuild segmento do processo de compilação. Fazendo alterações neste segmento, você pode personalizar como binários são compilados e tratados com mais eficiência. Especificamente, este tópico descreve como realizar as seguintes tarefas:

    • Passar argumentos para MSBuild e usá-los em seus projetos de código para alterar como os binários compilados são manipulados.

    • Configurar uma biblioteca de código comum centralizado seu próprio MSBuild elementos, tais como os grupos de propriedade ou destinos. Ao configurar esse tipo de biblioteca, você pode ativar sua equipe modificar as principais partes da sua lógica do processo de compilação e reutilizar facilmente.

ObservaçãoObservação

Este tópico aborda os três tipos de projetos de código: C#, C++, and Visual Basic. No entanto, você poderá usar as técnicas para outros tipos de projetos de código.

Neste tópico

  • Permissões necessárias

  • O processo de compilação padrão que armazenará os binários compilados

  • Organizar os binários compilados usando uma lógica que está incorporada em cada projeto de código

    • Visão geral do processo

    • Visão geral das etapas a seguir

    • Criar a definição de compilação e o CustomOutputDirInline personalizado construir o modelo de processo

    • Incorporar a lógica da pasta de soltar em seus projetos de código

  • Organizar os binários compilados usando lógica é mantida em dois arquivos centralizados

    • Visão geral do processo

    • Visão geral das etapas a seguir

    • Criar os arquivos código MSBuild comuns que contêm a lógica da pasta drop

    • Criar a definição de compilação e o CustomOutputDirImport personalizado construir o modelo de processo

    • Atualizar a definição de compilação de OurTeamBuild

    • Importar a lógica da pasta de soltar a seus projetos de código

  • Próximas etapas

Permissões necessárias

Para executar os procedimentos a seguir, você deve ter as seguintes permissões definidas Permitir:

  • Editar definição de compilação.

  • Fazer check-out e Check-in para os diretórios de controle de versão relevantes.

  • Compilações de fila.

Para obter mais informações, consulte Permissões de Team Foundation Server.

Onde o processo de compilação padrão cai binários compilados

Não importa como o seu trabalho é dividido em soluções e projetos de código, o processo de compilação padrão coloca a todos os binários compilados em um único subdiretório na pasta drop. Por exemplo, você poderia ter as seguintes soluções e projetos de código:

  • SolutionA

    • CPPWin32ConsoleApp (um aplicativo de console do Visual C++)

    • CSharpConsoleApp (um aplicativo de console Visual C#)

  • SolutionB

    • VBConsoleApp (um Visual Basic aplicativo de console)

O diagrama a seguir ilustra como e onde MSBuild descarta os binários após terem sido compilados como parte do processo que está especificado em DefaultTemplate.xaml.

FluxoPadrão

Organizar os binários compilados usando uma lógica que está incorporada em cada projeto de código

Você pode especificar que serão eliminados os binários compilados em uma estrutura de subpasta que corresponda à estrutura de suas soluções e projetos de código.

Visão geral do processo

O diagrama a seguir ilustra em um alto nível, como é possível implementar um processo de compilação:

Fluxo de lógica personalizada de saída incorporada

Visão geral das etapas a seguir

Em suma, você pode executar as seguintes etapas para criar esse tipo de processo de compilação personalizada com base em DefaultTemplate.xaml:

  • Etapa 1 Definição de compilação e construir o modelo de processo

    • Criar uma definição de compilação (chamado, por exemplo, OurTeamBuild). Sobre o processo guia, basear a definição de compilação de um novo modelo de processo de compilação (chamado, por exemplo, CustomOutputDirInline.xaml).

    • Em CustomOutputDirInline.xaml, execute as seguintes etapas na instância da Run MSBuild for Project atividade que compila o código:

      • Desativar o OutDir propriedade da Run MSBuild for Project atividade removendo seu valor para torná-lo uma seqüência de caracteres vazia.

        ObservaçãoObservação

        Se você não fizer essa alteração, o OutDir propriedade substitui qualquer lógica de estrutura de diretório personalizado que você implementar o projeto de código.

      • Coletar o valor de seqüência de caracteres que contém a pasta de recebimento do agente de compilação da BinariesDirectory variável e passá-lo em um MSBuild argumento (chamado, por exemplo, TeamBuildOutDir).

  • Etapa 2 Projetos de código

    • Cada código de projeto que o OurTeamBuild criar compilações, adicione o elemento apropriado (ou OutputPath ou OutDir) para definir a estrutura de subdiretório será criada em suas pastas de soltar.

As subseções a seguir explicam detalhadamente como executar essas etapas.

Criar a definição de compilação e o CustomOutputDirInline personalizado construir o modelo de processo

Para dispor a base do processo de compilação, criando uma definição de compilação e baseá-lo em um novo modelo de processo de compilação.

Para criar a definição de compilação e o modelo de processo de compilação

  1. Crie uma definição de compilação.

    1. Sobre o Geral guia, dê um nome de definição de compilação (por exemplo, OurTeamBuild).

    2. Sobre o processo guia, adicione as soluções que você deseja criar.

      Para obter mais informações, consulte Criar uma definição de compilação básico.

  2. No processo guia da OurTeamBuild definição de compilação, defina o modelo de processo de compilação para um novo modelo de processo de compilação que é denominado CustomOutputDirInline.xaml e que se baseia no modelo padrão (DefaultTemplate.xaml).

    Para obter mais informações, consulte Criar e trabalhar com um modelo de processo de compilação personalizados.

  3. Em Gerenciador de controle de código-fonte, abra seu projeto de equipe e exibir a pasta que contém os modelos de processo de compilação.

    Por padrão, esse subdiretório chamado BuildProcessTemplates.

  4. Check-out e, em seguida, clique duas vezes o CustomOutputDirInline.xaml o arquivo que você criou anteriormente este procedimento.

  5. No designer de fluxo de trabalho, encontre a segunda instância da Run MSBuild for Project atividade, que está localizada na seguinte estrutura:

    1. Seqüência (Sequence) >

    2. Executar o agente (AgentScope) >

    3. Tente compilar, teste e associar conjuntos de alterações e itens de trabalho (TryCatch [Try]) >

    4. Seqüência (Sequence) >

    5. Compile, teste e associar os conjuntos de alterações e itens de trabalho (Parallel) >

    6. Tente compilar e testar TryCatch [Try] >

    7. Compilar e testar Sequence >

    8. Para cada configuração de BuildSettings.PlatformConfigurationsForEach [Body] >

    9. Compilar e testar a configuração Sequence >

    10. Se BuildSettings.HasProjectsToBuild If [Then] >

    11. Para cada projeto BuildSettings.ProjectsToBuildForEach [Body] >

    12. Tente compilar o projeto TryCatch [Try] >

    13. Compilar o projeto Sequence >

    14. Executar o MSBuild para projetoMSBuild

    Para obter informações sobre como navegar essa estrutura, consulte Navegar em um fluxo de trabalho do Windows complexo.

  6. Com o botão direito do Run MSBuild for Project atividade e então clique em Propriedades.

  7. No Propriedades painel, remover os dados a OutDir caixa para definir esta propriedade como uma seqüência de caracteres vazia.

  8. No Propriedades definido do painel, o CommandLineArguments a propriedade para o seguinte valor:

    String.Format("/p:SkipInvalidConfigurations=true;TeamBuildOutDir=""{0}"" {1}",
BinariesDirectory, MSBuildArguments)

  9. Save CustomOutputDirInline.xaml.

  10. Em Gerenciador de controle de código-fonte, verificar as suas alterações nesse arquivo.

Incorporar a lógica da pasta de soltar em seus projetos de código

Agora que você criou sua definição de compilação e o modelo de processo de compilação personalizada, você deve incorporar a lógica da estrutura de diretório em cada projeto de código que o processo de compilação compila.

ObservaçãoObservação

Você não pode incorporar essa lógica no próprio fluxo de trabalho porque a DefaultTemplate.xaml fluxo de trabalho não iterar e executar cada projeto por meio de MSBuild compilador. Em vez disso, o fluxo de trabalho chama MSBuild uma vez para compilar todas as soluções e projetos.

Para incorporar a lógica da pasta drop

  1. Em Gerenciador de controle de código-fonte, abra uma solução que o OurTeamBuild criar compilações de definição.

  2. Adicione o elemento de diretório de saída necessária para cada projeto de código na solução. Para projetos de código gerenciado, como Visual C# ou Visual Basic, essa propriedade é OutputPath. Para projetos Visual C++, esta propriedade é OutDir. Para cada projeto de código na solução, siga estas etapas:

    1. Em Solution Explorer, clique com o botão direito no projeto. Se o Unload Project comando está disponível, clique nela.

    2. Clique com o botão direito do projeto e clique em Editar ProjectName.

    3. Execute uma das seguintes etapas:

      • Se o projeto for um projeto de código gerenciado, como, por exemplo, Visual C# ou Visual Basic: Adicionar um OutputPath elemento. Você deve posicionar este elemento após o último OutputPath elemento que já está no código do projeto, como mostra o exemplo a seguir:

        <Project DefaultTargets="Build" xmlns="https://schemas.microsoft.com/developer/msbuild/2003 ...">
 ...
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86'">
 ...
 <OutputPath>bin\Debug\</OutputPath>
 ...
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
 ...
 <OutputPath>bin\Release\</OutputPath>
 ...
</PropertyGroup>

<PropertyGroup Condition="$(TeamBuildOutDir) != '' ">
<OutputPath>$(TeamBuildOutDir)\$(SolutionName)\$(MSBuildProjectName)\$(Configuration)</OutputPath>
</PropertyGroup>

      • Se o projeto for um projeto Visual C++: Adicionar um OutDir elemento. Você deve posicionar este elemento antes do elemento que importa Microsoft.Cpp.targets, como mostra o exemplo a seguir:

        <Project DefaultTargets="Build" xmlns="https://schemas.microsoft.com/developer/msbuild/2003 ...">
...

<PropertyGroup Condition="$(TeamBuildOutDir) != '' ">
 <OutDir>$(TeamBuildOutDir)\$(SolutionName)\$(MSBuildProjectName)\$(Configuration)\</OutDir>
</PropertyGroup>

<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
</Project>

    4. Salve o projeto de código.

  3. No Solution Explorer, a solução com o botão direito e, em seguida, clique em Check-In.

  4. Repita essas etapas para cada solução que OurTeamBuild compilações.

Organizar os binários compilados usando lógica é mantida em dois arquivos central

Se você tiver muitos projetos de código para manter, você pode melhorar o processo descrito na seção anterior se você mantiver o OutputPath e OutDir elementos em dois arquivos compartilhados. Se você adotar essa abordagem, você pode alterar a estrutura de diretório da sua pasta de soltar mais facilmente modificando os dois arquivos centralizados, em vez de cada projeto de código.

Visão geral do processo

O diagrama a seguir ilustra em um alto nível, como é possível implementar um processo de compilação:

Fluxo de lógica de saída personalizado importada

Visão geral das etapas a seguir

Em suma, você deve executar as seguintes etapas para criar esse tipo de processo de compilação personalizada com base em DefaultTemplate.xaml:

  • Em Gerenciador de controle de código-fonte, crie um diretório (chamado, por exemplo, $/OurTeam/BuildProcessMSBuild) para conter o common MSBuild código. Nesse diretório, criar e armazenar o MSBuild os arquivos que definem a estrutura de subpasta que será criada em suas pastas de soltar.

  • Etapa 1 Definição de compilação e construir o modelo de processo

    • Atualizar a definição de compilação (chamado, por exemplo, OurTeamBuild), seguindo estas etapas:

      • Sobre o espaço de trabalho guia, mapear o $/OurTeam/BuildProcessMSBuild diretório.

      • Sobre o processo guia, basear a definição de compilação de um novo modelo de processo de compilação (chamado, por exemplo, CustomOutputDirImport.xaml).

    • Em CustomOutputDirImport.xaml, siga estas etapas:

      • Declarar LocalPathToMSBuildCode como um String variável tem como escopo o Run On Agent atividade.

      • Declarar ServerPathToMSBuildCode como um argumento.

        Após adicionar esse argumento, você deve modificar o OurTeamBuild definição. Sobre o processo guia, digite $/OurTeam/BuildProcessMSBuild como o valor deste parâmetro de processo de compilação.

      • No Run on Agent > atividade, antes do Try Compile, Test, and Associate Changesets and Work Items [Try] atividade, adicionar um ConvertWorkspaceItem atividade para converter o ServerPathToMSBuildCode argumento em um caminho local em que o agente de compilação que pode MSBuild pode processar. Em seguida, colocar esse valor LocalPathToMSBuildCode variável.

      • Na instância da Run MSBuild for Project atividade que compila o código, execute estas etapas:

        • Desativar o OutDir propriedade da Run MSBuild for Project atividade removendo seu valor para torná-lo uma seqüência de caracteres vazia.

          ObservaçãoObservação

          Se você não fizer essa alteração, o OutDir propriedade substitui qualquer lógica de estrutura de diretório personalizado que você implementar o projeto de código.

        • Coletar o valor de seqüência de caracteres que contém a pasta de recebimento do agente de compilação da BinariesDirectory variável e a passagem para que o valor em MSBuild como um argumento (chamado, por exemplo, TeamBuildOutDir).

        • Passar o valor de LocalPathToMSBuildCode em MSBuild como um argumento (chamado, por exemplo, CommonMSBuildCode).

  • Etapa 2 Projetos de código

    • Cada código de projeto que OurTeamBuild compila, adicionar um <Import /> elemento no local apropriado.

As subseções a seguir explicam em detalhes como siga estas etapas.

Criar os arquivos código MSBuild comuns que contêm a lógica da pasta drop

Essa abordagem, iniciar criando um diretório e dois MSBuild arquivos de projeto. Esses arquivos contêm a lógica que define a estrutura de subdiretório será criada em suas pastas de soltar.

Para criar os arquivos

  1. Em Gerenciador de controle de código-fonte, execute uma das seguintes etapas:

    • Localize o diretório onde você armazena seu MSBuild código comuns.

    • Crie um diretório para armazenar seu MSBuild comum de código e o nome, por exemplo, $/OurTeam/BuildProcessMSBuild.

  2. Se o não mapeados link aparece ao lado do Caminho Local rótulo na parte superior da Gerenciador de controle de código-fonte, clique no link para mapear o diretório do servidor para o diretório apropriado no seu espaço de trabalho local.

  3. Criar, salvar e verifique os seguintes arquivos $/OurTeam/BuildProcessMSBuild:

    • Gerenciado de um arquivo para conter a lógica da pasta de soltar para projetos de código, como Visual C# ou Visual Basic (chamado, por exemplo, ManagedCodeProjectOutDir.targets).

      <Project xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup Condition="$(TeamBuildOutDir) != '' ">
 <OutputPath>$(TeamBuildOutDir)\$(SolutionName)\$(MSBuildProjectName)\$(Configuration)</OutputPath>
</PropertyGroup>
</Project>

    • Um arquivo para conter a lógica da pasta de soltar para projetos de código do Visual C++ (chamado, por exemplo, CPPCodeProjectOutDir.targets).

      <Project xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup Condition="$(TeamBuildOutDir) != '' ">
 <OutDir>$(TeamBuildOutDir)\$(SolutionName)\$(MSBuildProjectName)\$(Configuration)\</OutDir>
</PropertyGroup>
</Project>

Criar a definição de compilação e o CustomOutputDirImport personalizado construir o modelo de processo

Você pode reutilizar a definição de compilação que você criou anteriormente neste tópico e nomeada OurTeamBuild. Você irá baseá-lo em um novo modelo de processo de compilação e fazer ajustes adicionais.

Para criar a definição de compilação e o modelo de processo de compilação

  1. Em Team Explorer, o botão direito do mouse OurTeamBuilde em seguida, clique em Editar.

  2. Clique o processo guia e, em seguida, defina o modelo de processo de compilação para um novo modelo de processo de compilação é denominado CustomOutputDirImport.xaml e que se baseia no modelo padrão (DefaultTemplate.xaml).

    Para obter mais informações, consulte Criar e trabalhar com um modelo de processo de compilação personalizados.

  3. Em Gerenciador de controle de código-fonte, abra seu projeto de equipe e exibir a pasta que contém os modelos de processo de compilação. Por padrão, o nome desse subdiretório é BuildProcessTemplates.

  4. Check-out e, em seguida, clique duas vezes o CustomOutputDirImport.xaml o arquivo que você criou anteriormente este procedimento.

  5. No designer de fluxo de trabalho, encontrar o Run on Agent atividade, que está localizada na seguinte estrutura:

    1. Seqüência (Sequence) >

    2. Executar o agente (AgentScope) >

    Para obter informações sobre como navegar essa estrutura, consulte Navegar em um fluxo de trabalho do Windows complexo.

  6. Na parte inferior da janela, clique em argumentos.

  7. No argumentos , crie um argumento e o nome ServerPathToMSBuildCode.

  8. No Propriedades painel, selecione o IsRequired caixa de seleção.

  9. Na parte inferior da janela, clique em variáveis de.

  10. No variáveis painel, declare uma variável chamada LocalPathToMSBuildCode com um tipo de String e um escopo de Run On Agent.

  11. Arrastar o ConvertWorkspaceItem atividade a partir de Atividades de compilação do Team Foundation seção a Toolbox no local entre o Initialize Workspace e If CreateLabel atividades.

    ObservaçãoObservação

    Se o Atividades de compilação do Team Foundation seção não aparece na Toolbox, você pode adicionar manualmente essa seção do Microsoft.TeamFoundation.Build.Workflow.dll assembly. Para obter mais informações, consulte How to: Add Activities to the Toolbox.

  12. Com o botão direito do ConvertWorkspaceItem atividade e então clique em Propriedades.

  13. No Propriedades painel, defina os seguintes valores de propriedade:

    • Exibir o nome: Get Local Path to MSBuild Code

    • Entrada: ServerPathToMSBuildCode

    • Resultado: LocalPathToMSBuildCode

    • Espaço de trabalho: Workspace

  14. Encontre a segunda instância da Run MSBuild for Project atividade, que está localizada na seguinte estrutura:

    1. Seqüência (Sequence) >

    2. Executar o agente (AgentScope) >

    3. Tente compilar, teste e associar conjuntos de alterações e itens de trabalho (TryCatch [Try]) >

    4. Seqüência (Sequence) >

    5. Compile, teste e associar os conjuntos de alterações e itens de trabalho (Parallel) >

    6. Tente compilar e testar TryCatch [Try] >

    7. Compilar e testar Sequence >

    8. Para cada configuração de BuildSettings.PlatformConfigurationsForEach [Body] >

    9. Compilar e testar a configuração Sequence >

    10. Se BuildSettings.HasProjectsToBuild If [Then] >

    11. Para cada projeto BuildSettings.ProjectsToBuildForEach [Body] >

    12. Tente compilar o projeto TryCatch [Try] >

    13. Compilar o projeto Sequence >

    14. Executar o MSBuild para projetoMSBuild

    Para obter informações sobre como navegar essa estrutura, consulte Navegar em um fluxo de trabalho do Windows complexo.

  15. Com o botão direito do Run MSBuild for Project atividade e então clique em Propriedades.

  16. No Propriedades painel, remover os dados a OutDir caixa para definir esta propriedade como uma seqüência de caracteres vazia.

  17. No Propriedades definido do painel, o CommandLineArguments a propriedade para o seguinte valor:

    String.Format("/p:SkipInvalidConfigurations=true;CommonMSBuildCode=""{0}"";TeamBuildOutDir=""{1}"" {2}",
LocalPathToMSBuildCode, BinariesDirectory, MSBuildArguments)

  18. Save CustomOutputDirImport.xaml.

    Em Gerenciador de controle de código-fonte, verificar as suas alterações nesse arquivo.

Atualizar a definição de compilação de OurTeamBuild

Em seguida, é necessário que as alterações para o OurTeamBuild build definition.

Para atualizar a definição de compilação

  1. Em Team Explorer, expanda o projeto de equipe, você está trabalhando, o constrói pasta, com o botão direito a OurTeamBuild build definition e então clique em Editar definição de compilação.

  2. Clique o espaço de trabalho guia e, em seguida, adicione uma entrada que possui os seguintes valores:

    • Status: Active

    • Pasta de controle de origem: OurTeam / $/ BuildProcessMSBuild

    • Pasta de agente de compilação: $(SourceDir) \BuildProcessMSBuild

  3. Clique o processo guia e o tipo de OurTeam / $/ BuildProcessMSBuild na ServerPathToMSBuildCode caixa.

  4. Salve a definição de compilação.

Importar a lógica da pasta de soltar a seus projetos de código

Depois que você criar a sua definição de compilação e modelo de processo de compilação do seu personalizada, você deve atualizar seus projetos de código para importar a lógica da estrutura de diretório.

Para importar a lógica da pasta drop

  1. Em Gerenciador de controle de código-fonte, clique duas vezes em uma solução que OurTeamBuild compilações.

  2. Para cada projeto de código na solução, siga estas etapas:

    1. Em Solution Explorer, clique com o botão direito no projeto. Se o Unload Project comando está disponível, clique nela.

    2. Clique com o botão direito do projeto e clique em Editar ProjectName.

    3. Execute uma das seguintes etapas:

      • Se o projeto for um projeto de código gerenciado como, por exemplo, Visual C# ou Visual Basic: Adicionar um Import elemento após o último OutputPath elemento já está no código do projeto, como mostra o exemplo a seguir:

        <Project DefaultTargets="Build" xmlns="https://schemas.microsoft.com/developer/msbuild/2003 ...">
 ...
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86'">
 ...
 <OutputPath>bin\Debug\</OutputPath>
 ...
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
 ...
 <OutputPath>bin\Release\</OutputPath>
 ...
</PropertyGroup>

<Import Condition=" $(CommonMSBuildCode) != ''" Project="$(CommonMSBuildCode)\ManagedCodeProjectOutDir.targets"/>

      • Se o projeto for um projeto Visual C++: Adicionar um Import elemento antes do elemento que importa Microsoft.Cpp.targets, como mostra o exemplo a seguir:

        <Project DefaultTargets="Build" xmlns="https://schemas.microsoft.com/developer/msbuild/2003 ...">
...
<Import Condition=" $(CommonMSBuildCode) != ''" Project="$(CommonMSBuildCode)\CPPCodeProjectOutDir.targets"/>

<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
</Project>

    4. Salve o projeto de código.

  3. Em Solution Explorer, a solução com o botão direito e, em seguida, clique em Check-In.

  4. Repita as etapas anteriores para cada solução que OurTeamBuild compilações.

Próximas etapas

Para acompanhar, você pode realizar as seguintes tarefas:

  • Modificar a lógica da pasta drop. Para atender aos requisitos da sua equipe, você pode modificar o conteúdo do OutputPath e OutDir elementos seções anteriores oferecidas.

  • Salve seu projeto de código personalizado como um modelo. Se sua equipe irá criar muitos projetos de código, você pode incluir automaticamente seu personalizado MSBuild lógica em novos projetos de código. Em Solution Explorer, clique no projeto de código, abra o arquivo menu e clique Exportar modelo.

Recursos adicionais

Você pode encontrar informações adicionais nos tópicos a seguir no site da Microsoft:

Consulte também

Conceitos

Usando o Gerenciador de controle de código-fonte

Configurar a sua máquina de desenvolvimento para trabalhar com projeto do sua equipe

Outros recursos

Referência do MSBuild