Controllare la posizione in cui il sistema di compilazione inserisce i binari

  • Articolo

Il processo di compilazione predefinito (come definito in DefaultTemplate.xaml), inserisce i binari compilati da tutti i progetti di codice in una singola directory. In alcuni casi, tuttavia, si desidera organizzare i binari in una struttura di cartelle più granulare e organizzata.

È possibile utilizzare le tecniche illustrate in questo argomento per creare un processo di compilazione personalizzato che inserisce i file binari in una struttura di directory progettata dall'utente. È inoltre possibile personalizzare i processi di compilazione in vari modi utilizzando gli stessi principi. In questo argomento vengono illustrate le tecniche seguenti:

  • Personalizzare il segmento di Windows Workflow del processo di compilazione. È consigliabile apportare le modifiche desiderate in questo segmento per personalizzare la maggior parte degli aspetti del processo di compilazione, fatta eccezione per la compilazione e la gestione dei binari. In particolare, in questo argomento viene descritto come eseguire le attività seguenti:

    • Creare un processo di compilazione personalizzato modificando una copia del modello predefinito (DefaultTemplate.xaml).

    • Dichiarare e utilizzare argomenti per passare dati nel flusso di lavoro.

    • Dichiarare e utilizzare variabili per raccogliere e passare dati tramite il flusso di lavoro.

    • Modificare il modo in cui il flusso di lavoro utilizza l'attività MSBuild per chiamare MSBuild.

    • Scaricare un file nel server di compilazione e utilizzare l'attività ConvertWorkspaceItem per rendere disponibile il file al processo di compilazione.

  • Personalizzare il segmento di MSBuild del processo di compilazione. Apportando le modifiche in questo segmento, è possibile personalizzare più efficacemente la modalità di compilazione e gestione dei binari. In particolare, in questo argomento viene descritto come eseguire le attività seguenti:

    • Passare argomenti a MSBuild, quindi utilizzarli nei progetti di codice per modificare la modalità di gestione dei binari compilati.

    • Impostare una libreria di codice comune centralizzata di elementi di MSBuild personalizzati, ad esempio gruppi di proprietà o destinazioni. L'impostazione di questo tipo di libreria, consente al team dir riutilizzare e modificare facilmente i componenti principali della logica del processo di compilazione.

Nota

In questo argomento vengono descritti tre tipi di progetti di codice: C#, C++ e Visual Basic. È tuttavia possibile utilizzare queste tecniche per altri tipi di progetti di codice.

In questo argomento

  • Autorizzazioni necessarie

  • Posizione del processo di compilazione predefinito in cui vengono inseriti i binari compilati

  • Organizzare i binari compilati tramite la logica incorporata in ogni progetto di codice

    • Cenni preliminari sul processo

    • Cenni preliminari sui passaggi da seguire

    • Creare la definizione di compilazione e il modello del processo di compilazione personalizzato CustomOutputDirInline

    • Incorporare la logica della cartella di ricezione nei progetti di codice

  • Organizzare i binari compilati tramite la logica gestita in due file centralizzati

    • Cenni preliminari sul processo

    • Cenni preliminari sui passaggi da seguire

    • Creare i file di codice comuni di MSBuild contenenti la logica della cartella di ricezione

    • Creare la definizione di compilazione e il modello del processo di compilazione personalizzato CustomOutputDirImport

    • Aggiornare la definizione di compilazione OurTeamBuild

    • Importare la logica della cartella di ricezione nei progetti di codice

  • Operazioni successive

Autorizzazioni necessarie

Per eseguire le procedure descritte di seguito, è necessario che le seguenti autorizzazioni siano impostate su Consenti:

  • Modifica definizione di compilazione.

  • Estrai e Archivia per le directory di controllo della versione appropriate.

  • Compilazioni coda.

Per ulteriori informazioni, vedere Autorizzazioni per Team Foundation Server.

Posizione del processo di compilazione predefinito in cui vengono inseriti i binari compilati

Indipendentemente dalla modalità di suddivisione del lavoro nei progetti di codice e nelle soluzioni, il processo di compilazione predefinito inserisce tutti i binari compilati in un'unica sottodirectory nella cartella di ricezione. Ad esempio, è possibile che si disponga delle soluzioni e dei progetti di codice seguenti:

  • SoluzioneA

    • CPPWin32ConsoleApp (un'applicazione console in Visual C++)

    • CSharpConsoleApp (un'applicazione console in Visual C#)

  • SoluzioneB

    • VBConsoleApp (un'applicazione console in Visual Basic)

Nel diagramma seguente viene illustrato come e dove MSBuild inserisce i binari dopo che sono stati compilati come parte del processo specificato in DefaultTemplate.xaml.

Flusso predefinito

Organizzare i binari compilati tramite la logica incorporata in ogni progetto di codice

È possibile specificare che i binari compilati verranno inseriti in una struttura di sottodirectory che corrisponde alla struttura delle soluzioni e dei progetti di codice.

Cenni preliminari sul processo

Nel diagramma seguente viene illustrato, a un livello elevato, come è possibile implementare un processo di compilazione:

Flusso con logica di output personalizzata incorporata

Cenni preliminari sui passaggi da seguire

In breve, è possibile eseguire uno di questi passaggi per creare questo tipo di processo di compilazione personalizzato basato su DefaultTemplate.xaml:

  • Passaggio 1 Definizione di compilazione e modello di processo di compilazione

    • Creare una definizione di compilazione (denominata, ad esempio, OurTeamBuild). Nella scheda Processo basare la definizione di compilazione su un nuovo modello di processo di compilazione (denominato, ad esempio, CustomOutputDirInline.xaml).

    • In CustomOutputDirInline.xaml effettuare le seguenti operazioni nell'istanza dell'attività Run MSBuild for Project che compila il codice:

      • Disabilitare la proprietà OutDir dell'attività Run MSBuild for Project rimuovendo il relativo valore in modo che diventi una stringa vuota.

        Nota

        Se non si esegue questa modifica, la proprietà OutDir esegue l'override di tutta la logica della struttura di directory personalizzata implementata nel progetto di codice.

      • Raccogliere il valore stringa contenente la cartella di ricezione dell'agente di compilazione dalla variabile BinariesDirectory e passarlo come argomento di MSBuild (denominato, ad esempio, TeamBuildOutDir).

  • Passaggio 2 Progetti di codice

    • In ogni progetto di codice compilato da OurTeamBuild, aggiungere l'elemento appropriato (OutputPath o OutDir) per definire la struttura di sottodirectory che verrà creata nelle cartelle di ricezione.

Nelle sottosezioni seguenti viene illustrato in dettaglio come eseguire queste operazioni.

Creare la definizione di compilazione e il modello del processo di compilazione personalizzato CustomOutputDirInline

Le fondamenta del processo di compilazione si ottengono creando una definizione di compilazione e basandola su un nuovo modello di processo di compilazione.

Per creare la definizione di compilazione e il modello di processo di compilazione

  1. Creare una definizione di compilazione.

    1. Nella scheda Generale assegnare un nome alla definizione di compilazione (ad esempio OurTeamBuild).

    2. Nella scheda Processo aggiungere le soluzioni che si desidera compilare.

      Per ulteriori informazioni, vedere Creare una definizione di compilazione di base.

  2. Nella scheda Processo della definizione di compilazione OurTeamBuild impostare il modello di processo di compilazione su un nuovo modello di processo di compilazione denominato CustomOutputDirInline.xaml e basato sul modello predefinito (DefaultTemplate.xaml).

    Per ulteriori informazioni, vedere Creare e utilizzare un modello di processo di compilazione personalizzato.

  3. In Esplora controllo codice sorgente aprire il progetto team e visualizzare la cartella contenente i modelli di processo di compilazione.

    Per impostazione predefinita, questa sottodirectory è denominata BuildProcessTemplates.

  4. Estrarre e quindi fare doppio clic sul file CustomOutputDirInline.xaml creato precedentemente in questa procedura.

  5. In Progettazione flussi di lavoro individuare la seconda istanza dell'attività Run MSBuild for Project, che si trova nella struttura seguente:

    1. Sequenza (Sequence) >

    2. Esegui su agente (AgentScope) >

    3. Prova la compilazione, il test e associa insiemi di modifiche ed elementi di lavoro (TryCatch [Try]) >

    4. Sequenza (Sequence) >

    5. Compila, esegue il test e associa insiemi di modifiche ed elementi di lavoro (Parallel) >

    6. Prova a compilare ed eseguire il test TryCatch [Try] >

    7. Compila ed esegui il test Sequence >

    8. Per ogni configurazione in BuildSettings.PlatformConfigurationsForEach [Body] >

    9. Compila ed esegui il test della configurazione Sequence >

    10. Se BuildSettings.HasProjectsToBuild If [Then] >

    11. Per ogni progetto in BuildSettings.ProjectsToBuildForEach [Body] >

    12. Prova a compilare il progetto TryCatch [Try] >

    13. Compila il progetto Sequence >

    14. Esegui MSBuild per il progetto MSBuild

    Per informazioni su come spostarsi in questa struttura, vedere Spostarsi in un flusso di lavoro di Windows complesso.

  6. Fare clic con il pulsante destro del mouse sull'attività Run MSBuild for Project, quindi scegliere Proprietà.

  7. Nel riquadro Proprietà rimuovere i dati nella casella OutDir per impostare questa proprietà su una stringa vuota.

  8. Nella finestra Proprietà impostare la proprietà CommandLineArguments sul seguente valore:

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

  9. Salvare CustomOutputDirInline.xaml.

  10. In Esplora controllo del codice sorgente archiviare le modifiche in questo file.

Incorporare la logica della cartella di ricezione nei progetti di codice

Dopo avere creato la definizione di compilazione e il modello di processo di compilazione, è necessario incorporare la logica della struttura di directory in ogni progetto di codice compilato da questo processo di compilazione.

Nota

Non è possibile incorporare questa logica nel flusso di lavoro stesso, perché il flusso di lavoro DefaultTemplate.xaml non viene ripetuto e non esegue ogni progetto tramite il compilatore di MSBuild. Al contrario, il flusso di lavoro chiama una volta MSBuild per compilare tutte le soluzioni e tutti i progetti.

Per incorporare la logica della cartella di ricezione

  1. In Esplora controllo codice sorgente aprire una soluzione compilata dalla definizione di compilazione OurTeamBuild.

  2. Aggiungere l'elemento della directory di output richiesto a ogni progetto di codice nella soluzione. Per i progetti di codice gestito, ad esempio Visual C# o Visual Basic, questa proprietà è OutputPath. Per i progetti di Visual C++, questa proprietà è OutDir. Per ogni progetto di codice nella soluzione, attenersi alla seguente procedura:

    1. In Esplora soluzioni fare doppio clic sul progetto. Se il comando Scarica progetto è disponibile, selezionarlo.

    2. Fare clic con il pulsante destro del mouse sul progetto, quindi scegliere Modifica Nomeprogetto.

    3. Effettuare uno dei passaggi indicati di seguito.

      • Se il progetto è un progetto di codice gestito, ad esempio Visual C# o Visual Basic:, aggiungere un elemento OutputPath. È necessario posizionare questo elemento dopo l'ultimo elemento OutputPath già presente nel progetto di codice, come illustrato nell'esempio seguente:

        <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 il progetto è un progetto di Visual C++: aggiungere un elemento OutDir. È necessario posizionare questo elemento prima dell'elemento che importa Microsoft.Cpp.targets, come illustrato nell'esempio seguente:

        <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. Salvare il progetto di codice.

  3. In Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione, quindi scegliere Archivia.

  4. Ripetere questi passaggi per ogni soluzione compilata da OurTeamBuild.

Organizzare i binari compilati tramite la logica gestita in due file centralizzati

Se si dispone di più progetti di codice da gestire, è possibile migliorare il processo descritto nella sezione precedente se gli elementi OutDir e OutputPath vengono mantenuti in due file condivisi. Se si adotta questo approccio, è possibile modificare più facilmente la struttura di directory della cartella di ricezione modificando due file centralizzati anziché ogni progetto di codice.

Cenni preliminari sul processo

Nel diagramma seguente viene illustrato, a un livello elevato, come è possibile implementare un processo di compilazione:

Flusso con logica di output personalizzata importata

Cenni preliminari sui passaggi da seguire

In breve, è necessario eseguire uno di questi passaggi per creare questo tipo di processo di compilazione personalizzato basato su DefaultTemplate.xaml:

  • In Esplora controllo codice sorgente creare una directory (denominata, ad esempio, $/OurTeam/BuildProcessMSBuild) per contenere il codice comune di MSBuild. In questa directory creare e archiviare i file di MSBuild che definiscono la struttura di sottodirectory che verrà creata nelle cartelle di ricezione.

  • Passaggio 1 Definizione di compilazione e modello di processo di compilazione

    • Aggiornare la definizione di compilazione (denominata, ad esempio, OurTeamBuild) attenendosi alla seguente procedura:

      • Nella scheda Area di lavoro eseguire il mapping della directory $/OurTeam/BuildProcessMSBuild.

      • Nella scheda Processo basare la definizione di compilazione su un nuovo modello di processo di compilazione (denominato, ad esempio, CustomOutputDirImport.xaml).

    • In CustomOutputDirImport.xaml attenersi ai passaggi riportati di seguito.

      • Dichiarare LocalPathToMSBuildCode come variabile String limitata all'attività Run On Agent.

      • Dichiarare ServerPathToMSBuildCode come argomento.

        Dopo aver aggiunto questo argomento, è necessario modificare la definizione OurTeamBuild. Nella scheda Processo digitare $/OurTeam/BuildProcessMSBuild come valore di questo parametro del processo di compilazione.

      • Nell'attività Run on Agent >, prima dell'attività Try Compile, Test, and Associate Changesets and Work Items [Try], aggiungere un'attività ConvertWorkspaceItem per convertire l'argomento ServerPathToMSBuildCode in un percorso locale dell'agente di compilazione che possa essere elaborato da MSBuild. Inserire quindi questo valore nella variabile LocalPathToMSBuildCode.

      • Nell'istanza dell'attività Run MSBuild for Project che compila il codice, effettuare le seguenti operazioni:

        • Disabilitare la proprietà OutDir dell'attività Run MSBuild for Project rimuovendo il relativo valore in modo che diventi una stringa vuota.

          Nota

          Se non si esegue questa modifica, la proprietà OutDir esegue l'override di tutta la logica della struttura di directory personalizzata implementata nel progetto di codice.

        • Raccogliere il valore stringa contenente la cartella di ricezione dell'agente di compilazione dalla variabile BinariesDirectory e passare il valore a MSBuild come argomento (denominato, ad esempio, TeamBuildOutDir).

        • Passare il valore di LocalPathToMSBuildCode a MSBuild come argomento (denominato, ad esempio, CommonMSBuildCode).

  • Passaggio 2 Progetti di codice

    • In ogni progetto di codice compilato da OurTeamBuild, aggiungere un elemento <Import /> nella posizione appropriata.

Nelle sottosezioni seguenti viene illustrato in dettaglio come eseguire queste operazioni.

Creare i file di codice comuni di MSBuild contenenti la logica della cartella di ricezione

Per questo approccio, iniziare creando una directory e due file di progetto di MSBuild. In questi file è contenuto la logica che definisce la struttura di sottodirectory che verrà creata nelle cartelle di ricezione.

Per creare i file

  1. In Esplora controllo codice sorgente effettuare una delle operazioni seguenti:

    • Individuare la directory in cui viene archiviato il codice comune di MSBuild.

    • Creare una directory per archiviare il codice comune di MSBuild e denominarla, ad esempio, $/OurTeam/BuildProcessMSBuild.

  2. Se il collegamento Non mappato viene visualizzato accanto all'etichetta Percorso locale nella parte superiore di Esplora controllo codice sorgente, fare clic sul collegamento per eseguire il mapping della directory del server alla directory appropriata nell'area di lavoro locale.

  3. Creare, salvare e archiviare i seguenti file in $/OurTeam/BuildProcessMSBuild:

    • Un file per contenere la logica della cartella di ricezione per i progetti di codice gestito, ad esempio Visual C# o Visual Basic (denominato, ad esempio, ManagedCodeProjectOutDir.targets).

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

    • Un file per contenere la logica della cartella di ricezione per i progetti di codice Visual C++ (denominato, ad esempio, CPPCodeProjectOutDir.targets).

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

Creare la definizione di compilazione e il modello del processo di compilazione personalizzato CustomOutputDirImport

È possibile riutilizzare la definizione di compilazione creata precedentemente in questo argomento e denominata OurTeamBuild. Basare tale definizione su un nuovo modello di processo di compilazione e apportare modifiche aggiuntive.

Per creare la definizione di compilazione e il modello di processo di compilazione

  1. In Team Explorer fare clic con il pulsante destro del mouse su OurTeamBuild, quindi scegliere Modifica.

  2. Fare clic sulla scheda Processo, quindi impostare il modello di processo di compilazione su un nuovo modello di processo di compilazione denominato CustomOutputDirImport.xaml e basato sul modello predefinito (DefaultTemplate.xaml).

    Per ulteriori informazioni, vedere Creare e utilizzare un modello di processo di compilazione personalizzato.

  3. In Esplora controllo codice sorgente aprire il progetto team e visualizzare la cartella contenente i modelli di processo di compilazione. Per impostazione predefinita, il nome di questa sottodirectory è BuildProcessTemplates.

  4. Estrarre e quindi fare doppio clic sul file CustomOutputDirImport.xaml creato precedentemente in questa procedura.

  5. In Progettazione flussi di lavoro individuare l'attività Run on Agent, che si trova nella struttura seguente:

    1. Sequenza (Sequence) >

    2. Esegui su agente (AgentScope) >

    Per informazioni su come spostarsi in questa struttura, vedere Spostarsi in un flusso di lavoro di Windows complesso.

  6. Nella parte inferiore della finestra fare clic su Argomenti.

  7. Nel riquadro Argomenti creare un argomento e denominarlo ServerPathToMSBuildCode.

  8. Nel riquadro Proprietà selezionare la casella di controllo IsRequired.

  9. Nella parte inferiore della finestra fare clic su Variabili.

  10. Nel riquadro Variabili dichiarare una variabile denominata LocalPathToMSBuildCode con un tipo String e un ambito Run On Agent.

  11. Trascinare l'attività ConvertWorkspaceItem dalla sezione Attività Team Foundation Build della Casella degli strumenti nella posizione tra le attività Initialize Workspace e If CreateLabel.

    Nota

    Se la sezione di Attività Team Foundation Build non viene visualizzata nella Casella degli strumenti, è possibile aggiungere manualmente questa sezione dall'assembly Microsoft.TeamFoundation.Build.Workflow.dll. Per ulteriori informazioni, vedere How to: Add Activities to the Toolbox.

  12. Fare clic con il pulsante destro del mouse sull'attività ConvertWorkspaceItem, quindi scegliere Proprietà.

  13. Nel riquadro Proprietà impostare i seguenti valori della proprietà:

    • Nome visualizzato: Get Local Path to MSBuild Code

    • Input: ServerPathToMSBuildCode

    • Risultato: LocalPathToMSBuildCode

    • Area di lavoro: Workspace

  14. Individuare la seconda istanza dell'attività Run MSBuild for Project, che si trova nella struttura seguente:

    1. Sequenza (Sequence) >

    2. Esegui su agente (AgentScope) >

    3. Prova la compilazione, il test e associa insiemi di modifiche ed elementi di lavoro (TryCatch [Try]) >

    4. Sequenza (Sequence) >

    5. Compila, esegue il test e associa insiemi di modifiche ed elementi di lavoro (Parallel) >

    6. Prova a compilare ed eseguire il test TryCatch [Try] >

    7. Compila ed esegui il test Sequence >

    8. Per ogni configurazione in BuildSettings.PlatformConfigurationsForEach [Body] >

    9. Compila ed esegui il test della configurazione Sequence >

    10. Se BuildSettings.HasProjectsToBuild If [Then] >

    11. Per ogni progetto in BuildSettings.ProjectsToBuildForEach [Body] >

    12. Prova a compilare il progetto TryCatch [Try] >

    13. Compila il progetto Sequence >

    14. Esegui MSBuild per il progetto MSBuild

    Per informazioni su come spostarsi in questa struttura, vedere Spostarsi in un flusso di lavoro di Windows complesso.

  15. Fare clic con il pulsante destro del mouse sull'attività Run MSBuild for Project, quindi scegliere Proprietà.

  16. Nel riquadro Proprietà rimuovere i dati nella casella OutDir per impostare questa proprietà su una stringa vuota.

  17. Nella finestra Proprietà impostare la proprietà CommandLineArguments sul seguente valore:

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

  18. Salvare CustomOutputDirImport.xaml.

    In Esplora controllo del codice sorgente archiviare le modifiche in questo file.

Aggiornare la definizione di compilazione OurTeamBuild

A questo punto, è necessario apportare modifiche alla definizione di compilazione OurTeamBuild.

Per aggiornare la definizione di compilazione

  1. In Team Explorer espandere il progetto team che si sta utilizzando, espandere la cartella Compilazioni, fare clic con il pulsante destro del mouse sulla definizione di compilazione OurTeamBuild e scegliere Modifica definizione compilazione.

  2. Fare clic sulla scheda Area di lavoro, quindi aggiungere una voce con i seguenti valori:

    • Stato: Attivo

    • Cartella del controllo del codice sorgente: $/OurTeam/BuildProcessMSBuild

    • Cartella agente di compilazione: $) \ BuildProcessMSBuild (SourceDir

  3. Fare clic sulla scheda Processo e digitare $/OurTeam/BuildProcessMSBuild nella casella ServerPathToMSBuildCode.

  4. Salvare la definizione di compilazione.

Importare la logica della cartella di ricezione nei progetti di codice

Dopo aver creato la definizione di compilazione e il modello di processo di compilazione personalizzato, è necessario aggiornare i progetti di codice per importare la logica della struttura di directory.

Per importare la logica della cartella di ricezione

  1. In Esplora controllo codice sorgente fare doppio clic su una soluzione compilata da OurTeamBuild.

  2. Per ogni progetto di codice nella soluzione, attenersi alla seguente procedura:

    1. In Esplora soluzioni fare doppio clic sul progetto. Se il comando Scarica progetto è disponibile, selezionarlo.

    2. Fare clic con il pulsante destro del mouse sul progetto, quindi scegliere Modifica Nomeprogetto.

    3. Effettuare uno dei passaggi indicati di seguito.

      • Se il progetto è un progetto di codice gestito, ad esempio Visual C# o Visual Basic:, aggiungere un elemento Import dopo l'ultimo elemento OutputPath già presente nel progetto di codice, come illustrato nel seguente esempio:

        <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 il progetto è un progetto di Visual C++: aggiungere un elemento Import prima dell'elemento che importa Microsoft.Cpp.targets, come illustrato nell'esempio seguente:

        <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. Salvare il progetto di codice.

  3. In Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione, quindi scegliere Archivia.

  4. Ripetere i passaggi precedenti per ogni soluzione compilata da OurTeamBuild.

Operazioni successive

È possibile effettuare le attività aggiuntive riportate di seguito:

  • Modificare la logica della cartella di ricezione. Per soddisfare le esigenze del team, è possibile modificare il contenuto degli elementi OutDir e OutputPath presentati nelle sezioni precedenti.

  • Salvare il progetto di codice personalizzato come modello. Se il team prevede di creare molti progetti di codice, è possibile includere automaticamente la logica personalizzata di MSBuild nei nuovi progetti di codice. In Esplora soluzioni fare clic sul progetto di codice, quindi scegliere Esporta modello dal menu File.

Risorse supplementari

È possibile ottenere informazioni aggiuntive negli argomenti seguenti del sito Web Microsoft:

Vedere anche

Concetti

Utilizzo di Esplora controllo del codice sorgente

Configurare il computer di sviluppo per l'utilizzo del progetto del team

Altre risorse

Riferimenti a MSBuild