Specificare gli eventi di compilazione (C#)

Usare gli eventi di compilazione per specificare i comandi eseguiti prima dell'avvio della compilazione o dopo il completamento della compilazione.

Specificare un evento di compilazione

1. In Esplora soluzioniselezionare il progetto per il quale si vuole specificare l'evento di compilazione.

2. Nel menu Progetto, fai clic su Proprietà {ProjectName} (o da Esplora soluzioni, premere ALT+Invio).

3. Selezionare Build > Eventi.

   

4. Nella sezione evento di pre-compilazione specificare la sintassi dell'evento di compilazione.

   Nota

   Gli eventi di pre-compilazione non vengono eseguiti se il progetto è aggiornato e non viene attivata alcuna compilazione.

5. Nella sezione evento di post-compilazione, specificare la sintassi dell'evento di compilazione.

   Nota

   Aggiungere un'istruzione call prima di tutti i comandi post-compilazione che eseguono file .bat. Ad esempio, call MyFile.bat o call MyFile.bat call MyFile2.bat. I percorsi possono essere assoluti o relativi alla cartella di output.

6. Nella sezione Quando eseguire l'evento di post-compilazione specificare in quali condizioni eseguire l'evento di post-compilazione.

Creare i comandi dell'evento di compilazione

I comandi degli eventi di compilazione possono includere qualsiasi comando valido nella finestra del prompt dei comandi o in un file di .bat. I comandi disponibili sono documentati nel riferimento ai comandi di Windows . Il nome di un file batch deve essere preceduto da call per assicurarsi che vengano eseguiti tutti i comandi successivi. Il file batch stesso viene eseguito dalla cartella di output, ad esempio bin/Debug. Se è necessario lo stesso file batch per tutte le configurazioni, è possibile inserirlo nella stessa cartella del file di progetto e usare un percorso relativo, ad esempio call ../../prebuild.bat.

È possibile eseguire script di PowerShell immettendo un comando come PowerShell MyPowerShellScript.ps1. Il percorso dello script di PowerShell può essere assoluto o può essere relativo alla directory del progetto. È necessario assicurarsi che i criteri di esecuzione per gli script di PowerShell nel sistema operativo siano impostati in modo appropriato per eseguire lo script. Vedere Informazioni sui criteri di esecuzione.

Se si vuole usare un'altra shell, ad esempio bash, in genere si usa la stessa sintassi dei comandi usata per avviare uno script della shell dal prompt dei comandi di Windows. L'uso di shell di terze parti non rientra nell'ambito di questa documentazione, ma i siti come Stack Overflow potrebbero essere utili.

Nel file di progetto

Quando si eseguono i passaggi precedenti, Visual Studio modifica il file di progetto aggiungendo la destinazione PreBuild o PostBuild e il codice MSBuild necessario per eseguire i passaggi forniti. È possibile aprire il file di progetto e visualizzare i passaggi. Modificare i passaggi nel file di progetto è corretto. Vedrai le modifiche nella sezione Build > Events delle proprietà del progetto dopo aver salvato le modifiche.

<Target Name="PreBuild" BeforeTargets="PreBuildEvent">
  <Exec Command="call prebuild.bat" />
</Target>

<Target Name="PostBuild" AfterTargets="PostBuildEvent">
  <Exec Command="call postbuild.bat" />
</Target>

L'elemento Exec fa riferimento all'attività Exec MSBuild. Per informazioni su quali altri parametri è possibile usare per personalizzare l'esecuzione, vedere l'attività Exec . Ad esempio, è possibile usare WorkingDirectory per impostare la cartella da cui viene eseguito l'eseguibile. Il valore predefinito è la directory che contiene il file di progetto.

<Exec Command="call prebuild.bat" WorkingDirectory="$(OutDir)">

È possibile usare le proprietà di MSBuild (macro), ad esempio OutDir nell'esempio precedente, come illustrato più avanti in questo articolo in Macro.

Errori e altri output

L'output degli eventi di compilazione viene scritto nella sezione Build della finestra di output . Per aprirlo, scegliere Visualizza>Altre finestre, finestra di outputoppure premere CTRL+ALT+O. Nell'elenco a discesa accanto a Mostra output da, scegliere Build.

Se l'evento di pre-compilazione o post-compilazione non viene completato correttamente, è possibile terminare la compilazione facendo uscire l'azione evento con un codice diverso da zero (0). Un codice di uscita zero indica un'azione riuscita; qualsiasi altro codice di uscita viene considerato un errore.

Se l'evento di pre-compilazione ha esito negativo, potresti visualizzare un errore simile a questo nella finestra Elenco Errori.

MSB3073    The command "call c:\source\repos\prebuild.bat" exited with code 1.

Se nella finestra di Elenco errori non sono presenti informazioni sufficienti, è possibile provare a usare la finestra di output per visualizzare l'output completo della compilazione, incluso qualsiasi output dei file batch.

Consiglio

La finestra elenco di errori è limitata a una sola riga di output, la prima riga immessa per l'evento. Se l'output della finestra Elenco Errori è importante per te, evita di inserire più di una riga nell'evento. Creare un file batch dal prompt dei comandi di Windows o nel sistema operativo e quindi usare solo call mybatchfile.bat per l'evento. Includere i comandi nel file batch stesso.

Per indicazioni sui comandi che è possibile usare nei file batch, vedere comandi di Windows.

Macro

Le "macro" comunemente disponibili (in realtà le proprietà di MSBuild) sono elencate in proprietà comuni di MSBuild. Per i progetti .NET SDK (.NET Core o .NET 5 e versioni successive), le proprietà aggiuntive sono elencate in proprietà MSBuild per Microsoft.NET.Sdk.

Negli script per gli eventi di compilazione potrebbe essere necessario fare riferimento ai valori di alcune variabili a livello di progetto, ad esempio il nome del progetto o il percorso della cartella di output. Nelle versioni precedenti di Visual Studio, queste sono state chiamate macro . L'equivalente alle macro nelle versioni recenti di Visual Studio sono proprietà MSBuild. MSBuild è il motore di compilazione usato da Visual Studio per elaborare il file di progetto quando esegue una compilazione. Un evento di compilazione nell'IDE genera un target MSBuild nel file di progetto. È possibile usare qualsiasi proprietà MSBuild disponibile nella destinazione nel file di progetto, ad esempio $(OutDir) o $(Configuration). Le proprietà di MSBuild disponibili in questi eventi dipendono dai file importati in modo implicito o esplicito in un file di progetto, ad esempio .props e .targets file e proprietà impostati nel file di progetto, ad esempio negli elementi PropertyGroup. Prestare attenzione a usare il nome esatto di ogni proprietà. Non viene segnalato errore se si digita una proprietà in modo errato. In tal caso, una proprietà non riconosciuta restituisce una stringa vuota.

Si supponga, ad esempio, di specificare un evento di pre-compilazione come segue:

L'evento di pre-compilazione genera la voce seguente, denominata Target nel file di progetto:

  <Target Name="PreBuild" BeforeTargets="PreBuildEvent">
    <Exec Command="echo Configuration: $(Configuration)&#xD;&#xA;echo DevEnvDir: $(DevEnvDir)&#xD;&#xA;echo OutDir: $(OutDir)&#xD;&#xA;echo ProjectDir: $(ProjectDir)&#xD;&#xA;echo VisualStudioVersion: $(VisualStudioVersion)&#xD;&#xA;echo AssemblySearchPaths: $(AssemblySearchPaths)&#xD;&#xA;echo AssemblyName: $(AssemblyName)&#xD;&#xA;echo BaseIntermediateOutputPath: $(BaseIntermediateOutputPath)&#xD;&#xA;echo CscToolPath: $(CscToolPath)" />
  </Target>

L'evento di compilazione viene visualizzato come destinazione che include l'attività Exec con l'input specificato come Command. Le nuove righe vengono codificate nel codice XML.

Quando si compila il progetto in questo esempio, l'evento di pre-compilazione stampa i valori di alcune proprietà. In questo esempio, $(CscToolPath) non produce alcun output, perché non è definito. Si tratta di una proprietà facoltativa che è possibile definire nel file di progetto per assegnare il percorso a un'istanza personalizzata del compilatore C#, ad esempio se si sta testando una versione diversa di csc.exeo un compilatore sperimentale.

L'output degli eventi di compilazione viene scritto nell'output di compilazione, disponibile nella finestra Output. Nell'elenco a discesa Mostra output da scegliere Compila.

Build started...
1>------ Build started: Project: ConsoleApp4, Configuration: Debug Any CPU ------
1>You are using a preview version of .NET. See: https://aka.ms/dotnet-core-preview
1>Configuration: Debug
1>DevEnvDir: C:\Program Files\Microsoft Visual Studio\2022\Preview\Common7\IDE\
1>OutDir: bin\Debug\net6.0\
1>ProjectDir: C:\source\repos\ConsoleApp4\ConsoleApp4\
1>VisualStudioVersion: 17.0
1>ALToolsPath:
1>AssemblySearchPaths: {CandidateAssemblyFiles};{HintPathFromItem};{TargetFrameworkDirectory};{RawFileName}
1>AssemblyName: ConsoleApp4
1>BaseIntermediateOutputPath: obj\
1>CscToolsPath:
1>Skipping analyzers to speed up the build. You can execute 'Build' or 'Rebuild' command to run analyzers.
1>ConsoleApp4 -> C:\source\repos\ConsoleApp4\ConsoleApp4\bin\Debug\net6.0\ConsoleApp4.dll

Nota

Alcuni scenari richiedono azioni di compilazione più complesse rispetto agli eventi di compilazione. Ad esempio, per molti scenari di generazione di codice comuni, è necessario gestire operazioni di pulizia e ricompilazione e potrebbe essere necessario abilitare la compilazione incrementale per i passaggi di generazione del codice, in modo che il passaggio venga eseguito solo se l'output non è aggiornato rispetto agli input. MSBuild è progettato per gestire in modo intelligente tutti questi scenari. Prendere in considerazione la creazione di un target personalizzato che specifica AfterTargets o BeforeTargets da eseguire in un punto specifico del processo di compilazione e per un ulteriore controllo negli scenari avanzati, considerare la creazione di un'attività personalizzata o esaminando i diversi modi in cui è possibile personalizzare la compilazione.

Esempio

1. Creare un file batch denominato postbuild.bat nella cartella del progetto, con il contenuto seguente:

   echo Copying output file %1 to %1.copy
   copy %1 %1.copy
   

   Ricorda che in un file batch %1 si riferisce al primo argomento passato.

2. Chiamare il file batch nella sezione evento post-compilazione delle proprietà del progetto e passare un argomento usando la proprietà MSBuild $(TargetPath).

   call postbuild.bat $(TargetPath)
   

3. Compilare il progetto e controllare la cartella di output. Accanto all'assembly compilato verrà visualizzato il file copiato. Nella finestra di output , nella sezione di Build, dovresti vedere l'output del file batch:

   1>Output file is C:\source\repos\ConsoleApp-BuildEvents\ConsoleApp-BuildEvents\bin\Debug\net6.0\ConsoleApp-BuildEvents.dll
   1>        1 file(s) copied.
   ========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========
   ========== Build started at 12:00 PM and took 00.723 seconds ==========
   

Contenuto correlato

• pagina Eventi di Build, Progettazione Progetto (C#)
• Finestra di dialogo per il comando di evento pre-compilazione/post-compilazione
• Procedura: Specificare gli eventi di compilazione (Visual Basic)
• Compila e build