Riferimenti alla riga di comando di MSBuild

Articolo
12/06/2023

Quando si usa MSBuild.exe per compilare un file di progetto o di soluzione, si possono includere varie opzioni per specificare diversi aspetti del processo.

Ogni opzione è disponibile in due forme: -opzione e /opzione. La documentazione mostra solo la forma -opzione. Le opzioni non distinguono tra maiuscole e minuscole. Se si esegue MSBuild da una shell diversa dal prompt dei comandi di Windows, gli elenchi di argomenti a un'opzione (separati da punti e virgola o virgole) potrebbero richiedere virgolette singole o doppie per assicurarsi che gli elenchi vengano passati a MSBuild anziché interpretati dalla shell.

Sintassi

MSBuild.exe [Switches] [ProjectFile]

Argomenti

Argomento	Descrizione
`ProjectFile`	Compila le destinazioni nel file di progetto specificato. Se non si specifica un file di progetto, in MSBuild viene eseguita una ricerca nella directory di lavoro corrente di un nome file la cui estensione termina in proj e viene usato il file in questione. È inoltre possibile specificare un file di soluzione di Visual Studio per questo argomento.

Commutatori

Switch	Forma breve	Descrizione
-detailedSummary[:`True` o `False`]	-ds[:`True` o `False`]	Se `True`, visualizzare informazioni dettagliate alla fine del log di compilazione sulle configurazioni compilate e su come sono state pianificate nei nodi.
-getItem:`itemName`,...		Scrivere il valore dell'elemento o degli elementi dopo la valutazione, senza eseguire la compilazione o se si usa l'opzione `-targets` o l'opzione `-getTargetResult` , scrivere i valori dopo la compilazione.
-getProperty:`propertyName`,...		Scrivere il valore della proprietà o delle proprietà dopo la valutazione, senza eseguire la compilazione o se si usa l'opzione `-targets` o l'opzione `-getTargetResult` , scrivere i valori dopo la compilazione.
-getTargetResult:`targetName`,...		Scrivere i valori di output delle destinazioni specificate.
-graphBuild[:`True` o `False`]	-graph[:`True` o `False`]	Determina la creazione e la compilazione di un grafo di progetto in MSBuild. La creazione di un grafico implica l'identificazione dei riferimenti di progetto alle dipendenze dei moduli. La compilazione del grafico implica il tentativo di compilare riferimenti al progetto prima dei progetti che vi fanno riferimento, a differenza della pianificazione tradizionale di MSBuild. Richiede MSBuild 16 o versione successiva.
-help	/? o -h	Visualizza le informazioni sull'utilizzo. Il comando seguente è un esempio: `msbuild.exe -?`
-ignoreProjectExtensions: `extensions`	-ignore: `extensions`	Ignora le estensioni specificate quando si devono individuare i file di progetto da compilare. Usare un punto e virgola o una virgola per separare più estensioni, come illustrato nel seguente esempio: `-ignoreprojectextensions:.vcproj,.sln`
-inputResultsCaches[:`cacheFile`[`;cacheFile2`]	-irc[:`cacheFile`[`;cacheFile2`]	Elenco separato da punto e virgola dei file della cache di input da cui MSBuild leggerà i risultati della compilazione. Se `-isolateProjects` è impostato su `False`, impostarlo su `True`.
-interactive[:`True` o `False`]	-	Indica che le azioni nella compilazione possono interagire con l'utente. Non usare questo argomento in uno scenario automatizzato in cui l'interattività non è prevista. Specificare -interactive equivale a specificare -interactive:true. Usare il parametro per eseguire l'override di un valore proveniente da un file di risposta.
-isolateProjects[:`True` o `MessageUponIsolationViolation` o `False`]	-isolate[:`True` o `MessageUponIsolationViolation` o `False`]	Fa sì che MSBuild compili ogni progetto in isolamento. Se impostato su `MessageUponIsolationViolation` (o sulla forma breve `Message`), vengono serializzati solo i risultati delle destinazioni di primo livello se viene fornito l'opzione `-outputResultsCache` . Questa opzione consiste nel ridurre le probabilità di una destinazione di isolamento che viola un progetto di dipendenza usando uno stato non corretto a causa della dipendenza da una destinazione memorizzata nella cache i cui effetti collaterali non vengono presi in considerazione. Ad esempio, la definizione di una proprietà. Questa modalità è più restrittiva, perché richiede che il grafico del progetto sia individuabile in modo statico in fase di valutazione, ma può migliorare la pianificazione e ridurre il sovraccarico di memoria durante la compilazione di un set di progetti di grandi dimensioni.
-lowPriority[:`True` o `False`]	-low[:`True` o `False`]	Determina l'esecuzione di MSBuild con priorità bassa del processo. Specificare `-lowPriority` equivale a specificare `-lowPriority:True`.
-maxCpuCount[:`number`]	-m[:`number`]	Specifica il numero massimo di processi simultanei da usare durante la compilazione. Se non si include questa opzione, il valore predefinito è 1. Se si include questa opzione senza specificare un valore, MSBuild usa fino al numero di processori nel computer. Per altre informazioni, vedere Compilazione di più progetti in parallelo. Nell'esempio seguente viene indicato a MSBuild di eseguire la compilazione usando tre processi MSBuild, consentendo la compilazione contemporanea di tre progetti: `msbuild myproject.proj -maxcpucount:3`
-noAutoResponse	-noautorsp	Non includere automaticamente file MSBuild.rsp o Directory.Build.rsp .
-nodeReuse:`value`	-nr:`value`	Abilitare o disabilitare il riutilizzo dei nodi MSBuild. È possibile specificare i valori seguenti: - True. I nodi rimangono al termine della compilazione in modo da poter essere usati nelle compilazioni successive (impostazione predefinita). - False. I nodi non rimangono al termine della compilazione. Un nodo corrisponde a un progetto che è in esecuzione. Se si include l'opzione -maxcpucount, più nodi possono essere eseguiti contemporaneamente.
-nologo		Non visualizza l'intestazione di avvio né il messaggio di copyright.
-preprocess[:`filepath`]	-pp[:`filepath`]	Crea un singolo file di progetto aggregato effettuando l'inlining di tutti i file che vengono importati durante una compilazione, contrassegnandone i limiti. È possibile usare questa opzione per determinare più facilmente quali file vengono importati, da dove i file vengono importati e quali file contribuiscono alla compilazione. Quando si usa questa opzione, il progetto non viene compilato. Se si specifica un oggetto `filepath`, il file di progetto aggregato viene restituito come output al file. In caso contrario, l'output viene visualizzato nella finestra della console. Per informazioni su come usare l'elemento `Import` per inserire un file di progetto in un altro file di progetto, vedere Elemento Import (MSBuild) e Procedura: Usare la stessa destinazione in più file di progetto.
-outputResultsCache[:cacheFile]	-orc[:cacheFile]	File della cache di output in cui MSBuild scrive il contenuto delle cache dei risultati di compilazione alla fine della compilazione. Se `-isolateProjects` è impostato su `False`, impostarlo su `True`.
-profileEvaluation:`<file>`	-	Profila la valutazione di MSBuild e scrive il risultato nel file specificato. Se l'estensione del file specificato è '.md', il risultato viene generato in formato Markdown. In caso contrario, viene generato un file separato da tabulazioni.
-property:`name`=`value`	-p:`name`=`value`	Imposta o esegue l'override delle proprietà specificate a livello di progetto, dove `name` è il nome della proprietà e `value` è il valore della proprietà. Specificare separatamente ogni proprietà o usare un punto e virgola o una virgola per separare più proprietà, come illustrato nel seguente esempio: `-property:WarningLevel=2;OutDir=bin\Debug`
-restore	-r	Esegue la destinazione `Restore` prima di compilare le destinazioni effettive.
-restoreProperty:`name=value`	-Rp:`name=value`	Impostare o eseguire l'override di queste proprietà a livello di progetto solo durante il ripristino e non usare le proprietà specificate con l'argomento -property. `name` è il nome della proprietà e `value` è il valore della proprietà. Usare un punto e virgola o una virgola per separare più proprietà o specificare ogni proprietà separatamente.
-target:`targets`	-t:`targets`	Compila le destinazioni specificate nel progetto. Specificare separatamente ogni destinazione o usare un punto e virgola o una virgola per separare più destinazioni, come illustrato nel seguente esempio: `-target:PrepareResources;Compile` Se si specificano destinazioni usando questa opzione, vengono eseguite invece di qualsiasi destinazione nell'attributo `DefaultTargets` nel file di progetto. Per altre informazioni, vedere Ordine di compilazione delle destinazioni e Procedura: Specificare quale destinazione compilare per prima. Una destinazione è un gruppo di attività. Per altre informazioni, vedere Destinazioni.
-targets[:`file`]	-ts[:`file`]	Scrivere l'elenco delle destinazioni disponibili nel file specificato (o nel dispositivo di output, se non è specificato alcun file), senza eseguire effettivamente il processo di compilazione.
-Toolsversion:`version`	-tv:`version`	Specifica un set di strumenti personalizzato. Un set di strumenti è costituito da attività, destinazioni e strumenti usati per compilare un'applicazione. Vedere Set di strumenti (ToolsVersion) e configurazioni standard e set di strumenti personalizzati.
-validate:[`schema`]	-val[`schema`]	Convalida il file di progetto e, se la convalida ha esito positivo, compila il progetto. Se non si specifica `schema`, il progetto viene convalidato in base allo schema predefinito. Se si specifica `schema`, il progetto viene convalidato in base allo schema specificato. L'impostazione seguente è un esempio: `-validate:MyExtendedBuildSchema.xsd`
-verbosity:`level`	-v:`level`	Specifica la quantità di informazioni da visualizzare nel log di compilazione. Ogni logger visualizza gli eventi in base al livello di dettaglio impostato per il logger. È possibile specificare i livelli di dettaglio seguenti: `q[uiet]`, , `n[ormal]m[inimal]`(impostazione predefinita), `d[etailed]`e `diag[nostic]`. L'impostazione seguente è un esempio: `-verbosity:quiet`
-versione	vnet-	Visualizza solo le informazioni sulla versione. Il progetto non viene compilato.
@`file`		Inserisce le opzioni della riga di comando da un file di testo. Se si dispone di più file, devono essere specificati separatamente. Per altre informazioni, vedere File di risposta MSBuild.
-warnAsError[:`code`[`;code2`]	-err[`:code`[`;code2`]	Elenco di codici di avviso da considerare come errori. Usare un punto e virgola o una virgola per separare più codici di avviso. Per considerare tutti gli avvisi come errori, usare l'opzione senza valori. Quando un avviso viene considerato come un errore, la destinazione continua a essere eseguita come se fosse un avviso, ma la compilazione complessiva non riesce. Esempio: `-err:MSB4130`
-warnNotAsError[:`code`[`;code2`]	-noerr[`:code`[`;code2`]	Elenco di codici di avviso che non devono essere promossi a errori. In particolare, se l'opzione warnAsError è impostata per alzare di livello tutti gli avvisi agli errori, i codici di errore specificati con warnNotAsError non vengono alzati di livello. Questo non ha alcun effetto se warnAsError non è impostato per alzare di livello tutti gli avvisi agli errori. Usare un punto e virgola o una virgola per separare più codici di avviso. Esempio: `-noerr:MSB4130`
-warnAsMessage[:`code`[`;code2`]	-noWarn[:`code`[`;code2`]	Elenco di codici di avviso da considerare come messaggi di importanza bassa. Usare un punto e virgola o una virgola per separare più codici di avviso. Esempio: `-noWarn:MSB3026`

Opzioni per logger

Switch	Forma breve	Descrizione
-binaryLogger[:[LogFile=]`output.binlog` [; ProjectImports=[None,Embed,ZipFile]]]	-bl	Serializza tutti gli eventi di compilazione in un file binario compresso. Per impostazione predefinita il file si trova nella directory corrente ed è denominato msbuild.binlog. Il registro binario è una descrizione dettagliata del processo di compilazione che in un secondo momento può essere usata per ricostruire i registri di testo e da altri strumenti di analisi. Un registro binario è in genere 10-20 volte inferiore rispetto a quello più dettagliato di diagnostica a livello di testo, ma sono incluse informazioni aggiuntive. Per impostazione predefinita, il logger binario raccoglie il testo di origine dei file di progetto, inclusi tutti i progetti importati e i file di destinazione durante la compilazione. Il commutatore facoltativo `ProjectImports` controlla questo comportamento: - ProjectImports = None. Non raccogliere le importazioni del progetto. - ProjectImports=Embed. Il progetto Embed importa il file di log (impostazione predefinita). - ProjectImports=ZipFile. Salvare i file di progetto nell'output<>.projectimports.zip dove <l'output> corrisponde al nome del file di log binario. L'impostazione predefinita per ProjectImports è Embed. Nota: il logger non raccoglie file di origine non MSBuild, ad esempio .cs, .cpp e così via. Un file .binlog può essere "riprodotto" passandolo a msbuild.exe come argomento anziché progetto o soluzione. Altri logger ricevono le informazioni contenute nel file di log come se fosse in corso la compilazione originale. Altre informazioni sul registro binario e relativo utilizzo sono disponibili all'indirizzo: https://github.com/dotnet/msbuild/blob/main/documentation/wiki/Binary-Log.md Esempi: - `-bl` - `-bl:output.binlog` - `-bl:output.binlog;ProjectImports=None` - `-bl:output.binlog;ProjectImports=ZipFile` - `-bl:..\..\custom.binlog` - `-binaryLogger`
-consoleLoggerParameters: `parameters`	-clp:`parameters`	Passa i parametri specificati al logger di console tramite cui le informazioni sulla compilazione vengono visualizzate nella finestra della console. È possibile specificare i parametri seguenti: - PerformanceSummary. Visualizza il tempo necessario per attività, destinazioni e progetti. - Riepilogo. Mostra il riepilogo di avvisi ed errori alla fine. - NoSummary. Non mostra il riepilogo di avvisi ed errori alla fine. - ErrorsOnly. Mostra solo gli errori. - WarningsOnly. Mostra solo gli avvisi. - NoItemAndPropertyList. Non mostra l'elenco degli elementi e delle proprietà che verrebbero visualizzati all'inizio di ogni compilazione del progetto se il livello di dettaglio fosse stato impostato su `diagnostic`. - ShowCommandLine. Mostra i messaggi `TaskCommandLineEvent`. - ShowProjectFile. Visualizzare il percorso del file di progetto nei messaggi di diagnostica. Questa impostazione è attiva per impostazione predefinita. - ShowTimestamp. Mostra il timestamp come prefisso di ogni messaggio. - ShowEventId. Mostra l'ID evento per ogni evento avviato, completato e per ogni messaggio. - ForceNoAlign. Non allinea il testo alla dimensione del buffer della console. - DisableConsoleColor. Usa i colori predefiniti della console per tutti i messaggi di registrazione. - DisableMPLogging. Disabilita lo stile di registrazione del multiprocessore dell'output quando è in esecuzione in modalità non multiprocessore. - EnableMPLogging. Abilita lo stile di registrazione del multiprocessore anche quando è in esecuzione in modalità non multiprocessore. Questo stile di registrazione è attivato per impostazione predefinita. - ForceConsoleColor. Usare i colori della console ANSI anche se la console non la supporta. - Verbosity. Esegue l'override dell'impostazione -verbosity per questo logger. Usare un punto e virgola per separare più parametri, come illustrato nell'esempio seguente: `-consoleloggerparameters:PerformanceSummary;NoSummary -verbosity:minimal` Il logger predefinito della console è al livello di dettaglio normale e include un .`Summary`
-distributedFileLogger	-dfl	Registra l'output di compilazione di ogni nodo MSBuild nel relativo file. Il percorso iniziale per questi file è la directory attuale. Per impostazione predefinita, i file sono denominati MSBuild<NodeId.log.> È possibile usare l'opzione -fileLoggerParameters per specificare la posizione dei file e altri parametri per fileLogger. Se si assegna un nome a un file di log usando l'opzione -fileLoggerParameters , il logger distribuito usa tale nome come modello e aggiunge l'ID del nodo a tale nome durante la creazione di un file di log per ogni nodo.
-distributedLogger: `central logger` `forwarding logger`	-dl:`central loggerforwarding logger`	Registra gli eventi di MSBuild, associando un'istanza di logger diversa a ogni nodo. Per specificare più logger, specificare ciascun logger separatamente. Usare la sintassi del logger per specificare un logger. Per la sintassi del logger, vedere l'opzione -logger . Negli esempi seguenti viene illustrato l'utilizzo di questa opzione: `-dl:XMLLogger,MyLogger,Version=1.0.2,Culture=neutral` `-dl:MyLogger,C:\My.dll*ForwardingLogger,C:\Logger.dll`
-fileLogger [`number`]	-fl[`number`]	Registra l'output di compilazione in un singolo file nella directory corrente. Se non si specifica `number`, il file di output viene denominato msbuild.log. Se si specifica `number`, il file di output è denominato msbuild<n>.log, dove <n> è `number`. `Number` può essere una cifra compresa tra 1 e 9. È possibile usare l'opzione -fileLoggerParameters per specificare la posizione dei file e altri parametri per fileLogger.
-fileLoggerParameters[`number`]: `parameters`	-flp[ `number`]: `parameters`	Specifica parametri aggiuntivi per il logger di file e il logger di file distribuito. La presenza di questa opzione implica che sia presente l'opzione -filelogger[`number`] corrispondente. `Number` può essere una cifra compresa tra 1 e 9. È possibile usare tutti i parametri elencati per -consoleloggerparameters. È inoltre possibile usare uno o più dei seguenti parametri: - LogFile. Percorso del file di log nel quale viene scritto il log di compilazione. Questo percorso viene aggiunto come prefisso ai nomi dei file di log tramite il logger di file distribuito. - Append. Determina se il log di compilazione viene aggiunto al file di log o se lo sovrascrive. Quando si imposta l'opzione, il log di compilazione viene aggiunto al file di log. Quando l'opzione non è presente, il contenuto di un file di log esistente viene sovrascritto. Esempio: `msbuild myfile.proj -flp:FileLogger,Microsoft.Build;logfile=MyLog.log;append` Se si include un'impostazione o `false` esplicita`true`, il log viene aggiunto indipendentemente dall'impostazione. Se non si include l'opzione di accodamento, il log viene sovrascritto. In questo caso, il file viene sovrascritto: `msbuild myfile.proj -flp:FileLogger,Microsoft.Build;logfile=MyLog.log` In questo caso, il file viene aggiunto: `msbuild myfile.proj -flp:FileLogger,Microsoft.Build;logfile=MyLog.log;append=true` In questo caso, il file viene aggiunto: `msbuild myfile.proj -flp:FileLogger,Microsoft.Build;logfile=MyLog.log;append=false` - Encoding. Specifica la codifica del file (ad esempio UTF-8, Unicode o ASCII). Nell'esempio seguente vengono generati file di log differenti per gli avvisi e gli errori: `-flp1:logfile=errors.txt;errorsonly -flp2:logfile=warnings.txt;warningsonly` Negli esempi seguenti vengono illustrate altre possibilità: `-fileLoggerParameters:LogFile=MyLog.log;Append; Verbosity=diagnostic;Encoding=UTF-8` `-flp:Summary;Verbosity=minimal;LogFile=msbuild.sum` `-flp1:warningsonly;logfile=msbuild.wrn` `-flp2:errorsonly;logfile=msbuild.err`
-logger: `logger`	-l:`logger`	Specifica il logger da usare per registrare eventi da MSBuild. Per specificare più logger, specificare ciascun logger separatamente. Usare la sintassi seguente per `logger`: [``LoggerClass``,]``LoggerAssembly``[;``LoggerParameters``] Usare la sintassi seguente per `LoggerClass`: [``PartialOrFullNamespace``.]``LoggerClassName Non è necessario specificare la classe logger se nell'assembly è contenuto esattamente un logger. Usare la sintassi seguente per `LoggerAssembly`: {``AssemblyName``[,``StrongName``] \|AssemblyFile``} I parametri del logger sono facoltativi e vengono passati al logger esattamente come vengono inseriti. Gli esempi seguenti usano l'opzione -logger. `-logger:XMLLogger,MyLogger,Version=1.0.2,Culture=neutral` `-logger:XMLLogger,C:\Loggers\MyLogger.dll;OutputAsHTML`
-noConsoleLogger	-noconlog	Disabilita il logger della console predefinito e non registra gli eventi nella console.
-terminalLogger[:`auto`,`on`,]`off`	-tl[:`auto`,`on`,`off`]	Abilitare o disabilitare il logger del terminale. Il logger del terminale fornisce un output di compilazione avanzato nella console in tempo reale, organizzato logicamente per progetto e progettato per evidenziare informazioni interattive. Specificare `auto` (o usare l'opzione senza argomenti) per usare il logger del terminale solo se l'output standard non viene reindirizzato. Non analizzare l'output o basarsi su di esso rimane invariato nelle versioni future. Questa opzione è disponibile in MSBuild 17.8 e versioni successive.

Esempio 1

L'esempio seguente compila la destinazione rebuild del progetto MyProject.proj.

MSBuild.exe MyProject.proj -t:rebuild

Esempio 2

È possibile usare MSBuild.exe per eseguire compilazioni più complesse. Ad esempio, è possibile compilare destinazioni specifiche di progetti specifici in una soluzione. Nell'esempio seguente viene ricompilato il progetto NotInSolutionFolder e pulito il progetto InSolutionFolder che si trova nella cartella della soluzione NewFolder.

msbuild SlnFolders.sln -t:NotInSolutionfolder:Rebuild;NewFolder\InSolutionFolder:Clean