Procedura dettagliata: creazione di un nuovo file di progetto MSBuild

I linguaggi di programmazione destinati a .NET Framework, ad esempio Visual C# e Visual Basic, utilizzano i file di progetto MSBuild per descrivere e controllare il processo di compilazione dell'applicazione.Quando si utilizza Visual Studio per creare un file di progetto MSBuild, il codice XML appropriato viene aggiunto automaticamente al file.Tuttavia, può risultare utile comprendere l'organizzazione del codice XML e come è possibile modificarlo per controllare una compilazione.Questa procedura dettagliata mostra come creare in modo incrementale un file di progetto di base utilizzando soltanto un editor di testo.I passaggi della procedura dettagliata sono i seguenti:

• Creazione di un file di origine di applicazione minimo.

• Creazione di un file di progetto MSBuild minimo.

• Estensione della variabile di ambiente PATH per includere MSBuild.

• Compilazione dell'applicazione tramite il file di progetto.

• Aggiunta di proprietà per controllare la compilazione.

• Controllo della compilazione mediante la modifica dei valori delle proprietà.

• Aggiunta di destinazioni nella build.

• Controllo della compilazione tramite la specifica di destinazioni.

• Compilazione incrementale.

Questa procedura dettagliata mostra come compilare il progetto tramite il prompt dei comandi ed esaminare i risultati.Per ulteriori informazioni su MSBuild e su come eseguirlo tramite il prompt dei comandi, vedere Procedura dettagliata: utilizzo di MSBuild.

Per completare la procedura dettagliata sono necessari MSBuild e il compilatore di Visual C#, entrambi disponibili in .NET Framework (versione 2.0, 3.5 o 4) che, pertanto, deve essere installato nel sistema in uso.

Creazione di un'applicazione minima

In questa sezione viene illustrato come creare un file di origine di applicazione di Visual C# minimo tramite un editor di testo.

Per creare l'applicazione minima

1. Al prompt dei comandi, passare alla cartella dove si desidera creare l'applicazione, ad esempio \Documenti o \Desktop.

2. Digitare md HelloWorld per creare una sottocartella denominata \HelloWorld\.

3. Digitare cd HelloWorld per passare alla nuova cartella.

4. Avviare Blocco note o un altro editor di testo, quindi digitare il codice seguente.

   using System;
   
   class HelloWorld
   {
       static void Main()
       {
   #if DebugConfig
           Console.WriteLine("WE ARE IN THE DEBUG CONFIGURATION");
   #endif
   
           Console.WriteLine("Hello, world!");
       }
   }
   

5. Salvare questo file di codice sorgente e denominarlo Helloworld.cs.

6. Compilare l'applicazione digitando csc helloworld.cs al prompt dei comandi.

7. Verificare l'applicazione digitando helloworld al prompt dei comandi.

   Verrà visualizzato il messaggio Hello, world!.

8. Eliminare l'applicazione digitando del helloworld.exe al prompt dei comandi.

Creazione di un file di progetto MSBuild minimo

Ora che si dispone di un file di origine di applicazione minimo, è possibile creare un file di progetto minimo per compilare l'applicazione.Questo file di progetto contiene gli elementi seguenti:

• Il nodo radice Project obbligatorio.

• Un nodo ItemGroup per contenere gli elementi Item.

• Un elemento Item che fa riferimento al file di origine dell'applicazione.

• Un nodo Target per contenere le attività necessarie per compilare l'applicazione.

• Un elemento Task per avviare il compilatore di Visual C# per compilare l'applicazione.

Per creare un file di progetto MSBuild minimo

1. Nell'editor di testo, sostituire il testo esistente con le due righe seguenti:

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

2. Inserire questo nodo ItemGroup come elemento figlio del nodo Project:

     <ItemGroup>
       <Compile Include="helloworld.cs" />
     </ItemGroup>
   

   Notare che questo nodo ItemGroup già contiene un elemento Item.

3. Aggiungere un nodo Target come elemento figlio del nodo Project.Denominare il nodo Build.

     <Target Name="Build">
     </Target>
   

4. Inserire questo elemento task come elemento figlio del nodo Target:

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

5. Salvare questo file di progetto e denominarlo Helloworld.csproj.

Il file di progetto minimo risulterà analogo al codice seguente:

<Project xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
  <Target Name="Build">
    <Csc Sources="@(Compile)"/>  
  </Target>
</Project>

Le attività nella destinazione Build vengono eseguite in sequenza.In questo caso, l'attività Csc del compilatore di Visual C# è l'unica attività.Questa attività deve ricevere un elenco di file di origine da compilare e tale elenco viene fornito dal valore dell'elemento Compile.L'elemento Compile fa riferimento a un solo file di origine, Helloworld.cs.

[!NOTA]

Nell'elemento Item è possibile utilizzare il carattere jolly asterisco (*) per fare riferimento a tutti i file che presentano l'estensione di file cs, come segue:

<Compile Include="*.cs" />

Tuttavia, è consigliabile evitare l'utilizzo di caratteri jolly poiché, in caso di aggiunta o eliminazione di file di origine, rende più difficile il debug e l'indirizzamento selettivo.

Estensione di PATH per includere MSBuild

Prima di poter accedere a MSBuild è necessario estendere la variabile di ambiente PATH affinché includa la cartella di .NET Framework.

Per estendere PATH affinché includa MSBuild

• Al prompt dei comandi digitare set PATH=%PATH%;%WINDIR%\Microsoft.Net\Framework\v4.0.Se nel sistema in uso è installata un'altra versione di .NET Framework, modificare di conseguenza il numero di versione.

  [!NOTA]

  È possibile che il nome della cartella di MSBuild nel computer in uso includa un numero di build quale v2.0.50727.In tal caso, includere il numero di build nella riga di comando. Ad esempio, set PATH=%PATH%;%WINDIR%\Microsoft.Net\Framework\v2.0.50727.

  In alternativa, se è stato installato Visual Studio, è possibile utilizzare il prompt dei comandi di Visual Studio, in quanto presenta una variabile PATH che include la cartella di MSBuild.

Utilizzo del file di progetto per compilare l'applicazione

A questo punto, per compilare l'applicazione, utilizzare il file di progetto appena creato.

Per compilare l'applicazione

1. Al prompt dei comandi digitare msbuild helloworld.csproj /t:Build.

   Ciò consente di compilare la destinazione Build del file di progetto Helloworld richiamando il compilatore di Visual C# per creare l'applicazione Helloworld.

2. Verificare l'applicazione digitando helloworld.

   Verrà visualizzato il messaggio Hello, world!.

[!NOTA]

Per visualizzare più dettagli sulla build è possibile aumentare il livello di dettaglio.Per impostare il livello di dettaglio su detailed, digitare uno di questi comandi al prompt dei comandi:

msbuild helloworld.csproj /t:Build /verbosity:detailed

Aggiunta di proprietà di compilazione

Per aumentare il controllo della compilazione è possibile aggiungere proprietà di compilazione al file di progetto.Aggiungere le proprietà seguenti:

• Una proprietà AssemblyName per specificare il nome dell'applicazione.

• Una proprietà OutputPath per specificare la cartella che contiene l'applicazione.

Per aggiungere le proprietà di compilazione

1. Eliminare l'applicazione esistente digitando del helloworld.exe al prompt dei comandi.

2. Nel file di progetto, inserire l'elemento PropertyGroup subito dopo l'elemento Project di apertura:

     <PropertyGroup>
       <AssemblyName>MSBuildSample</AssemblyName>
       <OutputPath>Bin\</OutputPath>
     </PropertyGroup>
   

3. Aggiungere questa attività alla destinazione Build subito prima dell'attività Csc:

       <MakeDir Directories="$(OutputPath)"      Condition="!Exists('$(OutputPath)')" />
   

   L'attività MakeDir crea una cartella con il nome specificato nella proprietà OutputPath, purché attualmente non esista alcuna cartella avente lo stesso nome.

4. Aggiungere questo attributo OutputAssembly all'attività Csc:

   <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
   

   Ciò fa in modo che il compilatore di Visual C# produca un assembly denominato dalla proprietà AssemblyName e lo inserisca nella cartella denominata dalla proprietà OutputPath.

5. Salvare le modifiche.

A questo punto, il file di progetto risulterà analogo al codice seguente:

<Project xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <AssemblyName>MSBuildSample</AssemblyName>
    <OutputPath>Bin\</OutputPath>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
  <Target Name="Build">
    <MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
    <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
  </Target>
</Project>

[!NOTA]

Anziché aggiungere il delimitatore di percorso di barra rovesciata (\) nell'attributo OutputAssembly dell'attività Csc è consigliabile aggiungerlo alla fine del nome della cartella quando la si specifica nell'elemento OutputPath.Pertanto,

<OutputPath>Bin\</OutputPath>

OutputAssembly=="$(OutputPath)$(AssemblyName).exe" />

è meglio di

<OutputPath>Bin</OutputPath>

OutputAssembly=="$(OutputPath)\$(AssemblyName).exe" />

Verifica delle proprietà di compilazione

Ora è possibile compilare l'applicazione tramite il file di progetto in cui sono state utilizzate le proprietà di compilazione per specificare la cartella di output e il nome dell'applicazione.

Per verificare le proprietà di compilazione

1. Al prompt dei comandi digitare msbuild helloworld.csproj /t:Build.

   Questo comando crea la cartella \Bin\, quindi richiama il compilatore di Visual C# per creare l'applicazione MSBuildSample e la inserisce nella cartella \Bin\.

2. Per verificare che la cartella \Bin\ sia sta creata e che contenga l'applicazione MSBuildSample, digitare dir Bin.

3. Verificare l'applicazione digitando Bin\MSBuildSample.

   Verrà visualizzato il messaggio Hello, world!.

Aggiunta di destinazioni di compilazione

Successivamente, aggiungere altre due destinazioni al file di progetto, come segue:

• Una destinazione Clean che elimina i file vecchi.

• Una destinazione Rebuild che utilizza l'attributo DependsOnTargets per imporre l'esecuzione dell'attività Clean prima dell'attività Build.

Ora che sono presenti più destinazioni è possibile impostare la destinazione Build come destinazione predefinita.

Per aggiungere destinazioni di compilazione

1. Nel file di progetto, aggiungere subito dopo la destinazione Build le due destinazioni seguenti:

     <Target Name="Clean" >
       <Delete Files="$(OutputPath)$(AssemblyName).exe" />
     </Target>
     <Target Name="Rebuild" DependsOnTargets="Clean;Build" />
   

   La destinazione Clean richiama l'attività Delete per eliminare l'applicazione.La destinazione Rebuild viene eseguita soltanto dopo l'esecuzione di entrambe le destinazioni Clean e Build.Benché sia priva di attività, la destinazione Rebuild comporta l'esecuzione della destinazione Clean prima della destinazione Build.

2. Aggiungere questo attributo DefaultTargets all'elemento Project di apertura:

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

   Ciò imposta la destinazione Build come destinazione predefinita.

A questo punto, il file di progetto risulterà analogo al codice seguente:

<Project DefaultTargets="Build" xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <AssemblyName>MSBuildSample</AssemblyName>
    <OutputPath>Bin\</OutputPath>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
  <Target Name="Build">
    <MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
    <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
  </Target>
  <Target Name="Clean" >
    <Delete Files="$(OutputPath)$(AssemblyName).exe" />
  </Target>
  <Target Name="Rebuild" DependsOnTargets="Clean;Build" />
</Project>

Verifica delle destinazioni di compilazione

È possibile utilizzare le nuove destinazioni di compilazione per verificare le funzionalità seguenti del file di progetto:

• Compilazione della build predefinita.

• Impostazione del nome dell'applicazione tramite il prompt dei comandi.

• Eliminazione dell'applicazione prima che venga compilata un'altra applicazione.

• Eliminazione dell'applicazione senza compilare un'altra applicazione.

Per verificare le destinazioni di compilazione

1. Al prompt dei comandi digitare msbuild helloworld.csproj /p:AssemblyName=Greetings.

   Poiché non è stata utilizzata l'opzione /t per impostare in modo esplicito la destinazione, MSBuild esegue la destinazione predefinita Build.L'opzione /p esegue l'override della proprietà AssemblyName e le assegna il nuovo valore Greetings.Ciò comporta la creazione di una nuova applicazione denominata Greetings.exe nella cartella \Bin\.

2. Per verificare che la cartella \Bin\ contenga sia l'applicazione MSBuildSample sia la nuova applicazione Greetings, digitare dir Bin.

3. Verificare l'applicazione Greetings digitando Bin\Greetings.

   Verrà visualizzato il messaggio Hello, world!.

4. Eliminare l'applicazione MSBuildSample digitando msbuild helloworld.csproj /t:clean.

   Ciò comporta l'esecuzione dell'attività Clean per rimuovere l'applicazione avente il valore predefinito della proprietà AssemblyName, ovvero MSBuildSample.

5. Eliminare l'applicazione Greetings digitando msbuild helloworld.csproj /t:clean /p:AssemblyName=Greetings.

   Ciò comporta l'esecuzione dell'attività Clean per rimuovere l'applicazione avente il valore specificato della proprietà AssemblyName, ovvero Greetings.

6. Per verificare che la cartella \Bin\ sia vuota, digitare dir Bin.

7. Digitare msbuild.

   Anche se non è stato specificato alcun file di progetto, MSBuild compila il file helloworld.csproj poiché nella cartella corrente esiste un solo file di progetto.Ciò comporta la creazione dell'applicazione MSBuildSample nella cartella \Bin\.

   Per verificare che la cartella \Bin\ contenga l'applicazione MSBuildSample, digitare dir Bin.

Compilazione incrementale

È possibile configurare MSBuild affinché compili una destinazione solo in caso di modifica dei file di origine o dei file di destinazione da cui la destinazione dipende.MSBuild utilizza il timestamp di un file per determinare se è stato modificato.

Per eseguire la compilazione incrementale

1. Nel file di progetto, aggiungere alla destinazione di apertura Build gli attributi seguenti:

   Inputs="@(Compile)" Outputs="$(OutputPath)$(AssemblyName).exe"
   

   Ciò specifica che la destinazione Build dipende dai file di input specificati nel gruppo di elementi Compile e che la destinazione di output è il file dell'applicazione.

   La destinazione Build risultante sarà analoga al codice seguente:

   <Target Name="Build" Inputs="@(Compile)" Outputs="$(OutputPath)$(AssemblyName).exe">
     <MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
     <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
   </Target>
   

2. Verificare la destinazione Build digitando msbuild /v:d al prompt dei comandi.

   Tenere presente che helloworld.csproj è il file di progetto predefinito e che Build è la destinazione predefinita.

   L'opzione /v:d specifica che verrà fornita una descrizione dettagliata del processo di compilazione.

   Verranno visualizzate le righe seguenti:

   Skipping target "Build" because all output files are up-to-date with respect to the input files.

   Input files: HelloWorld.cs

   Output files: Bin\MSBuildSample.exe

   MSBuild ignora la destinazione Build poiché nessuno dei file di origine è stato modificato dall'ultima compilazione dell'applicazione.

Esempio

Descrizione

Nell'esempio seguente viene illustrato un file di progetto che compila un'applicazione Visual C# e registra un messaggio contenente il nome del file di output.

Codice

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

    <!-- Set the application name as a property -->
    <PropertyGroup>
        <appname>HelloWorldCS</appname>
    </PropertyGroup>

    <!-- Specify the inputs by type and file name -->
    <ItemGroup>
        <CSFile Include = "consolehwcs1.cs"/>
    </ItemGroup>

    <Target Name = "Compile">
        <!-- Run the Visual C# compilation using input files of type CSFile -->
        <CSC
            Sources = "@(CSFile)"
            OutputAssembly = "$(appname).exe">
            <!-- Set the OutputAssembly attribute of the CSC task
            to the name of the executable file that is created -->
            <Output
                TaskParameter = "OutputAssembly"
                ItemName = "EXEFile" />
        </CSC>
        <!-- Log the file name of the output file -->
        <Message Text="The output file is @(EXEFile)"/>
    </Target>
</Project>

Esempio

Descrizione

Nell'esempio seguente viene illustrato un file di progetto che compila un'applicazione Visual Basic e registra un messaggio contenente il nome del file di output.

Codice

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

    <!-- Set the application name as a property -->
    <PropertyGroup>
        <appname>HelloWorldVB</appname>
    </PropertyGroup>

    <!-- Specify the inputs by type and file name -->
    <ItemGroup>
        <VBFile Include = "consolehwvb1.vb"/>
    </ItemGroup>

    <Target Name = "Compile">    
        <!-- Run the Visual Basic compilation using input files of type VBFile -->
        <VBC
            Sources = "@(VBFile)"
            OutputAssembly= "$(appname).exe">
            <!-- Set the OutputAssembly attribute of the VBC task
            to the name of the executable file that is created -->
            <Output
                TaskParameter = "OutputAssembly"
                ItemName = "EXEFile" />
        </VBC>
        <!-- Log the file name of the output file -->
        <Message Text="The output file is @(EXEFile)"/>
    </Target>
</Project>

Argomenti successivi

Visual Studio è in grado di eseguire automaticamente molte delle operazioni descritte in questa procedura dettagliata.Per imparare a utilizzare Visual Studio per creare, modificare, compilare e verificare i file di progetto MSBuild, vedere Procedura dettagliata: utilizzo di MSBuild.

Vedere anche

Altre risorse

MSBuild

Riferimenti a MSBuild