Condividi tramite

dotnet run

Questo articolo si applica a: ✔️ .NET 6 SDK e versioni successive

Nome

dotnet run: esegue il codice sorgente senza comandi espliciti di compilazione o avvio.

Riepilogo

dotnet run [<applicationArguments>]
  [-a|--arch <ARCHITECTURE>] [--artifacts-path <ARTIFACTS_DIR>]
  [-c|--configuration <CONFIGURATION>] [-e|--environment <KEY=VALUE>]
  [--file <FILE_PATH>] [-f|--framework <FRAMEWORK>] [--force] [--interactive]
  [--launch-profile <NAME>] [--no-build] [--no-dependencies]
  [--no-launch-profile] [--no-restore] [--os <OS>] [--project <PATH>]
  [-r|--runtime <RUNTIME_IDENTIFIER>] [--tl:[auto|on|off]]
  [-v|--verbosity <LEVEL>] [[--] [application arguments]]

dotnet run -h|--help

Descrizione

Il comando dotnet run offre un modo pratico per eseguire l'applicazione dal codice sorgente con un solo comando. Questo comando è utile per lo sviluppo iterativo veloce dalla riga di comando. Il comando dipende dal comando dotnet build per compilare il codice. Tutti i requisiti per la compilazione si applicano anche a dotnet run .

Nota

dotnet run non rispetta argomenti come /property:property=value, che vengono rispettati da dotnet build.

I file di output vengono scritti nel percorso predefinito, ovvero bin/<configuration>/<target>. Se ad esempio si ha un'applicazione netcoreapp2.1 e si esegue dotnet run, l'output viene inserito in bin/Debug/netcoreapp2.1. I file vengono sovrascritti in base alle esigenze. I file temporanei vengono inseriti nella directory obj.

Se il progetto specifica più framework, l'esecuzione di dotnet run genera un errore a meno che non venga usata l'opzione -f|--framework <FRAMEWORK> per specificare il framework.

Il comando dotnet run viene usato nel contesto dei progetti e non di assembly di compilazione. Se in alternativa si prova a eseguire la DLL di un'applicazione dipendente da framework, è necessario usare dotnet senza un comando. Ad esempio, per eseguire myapp.dll, usare:

dotnet myapp.dll

Per altre informazioni sul driver, vedere Panoramica dell'interfaccia della dotnet riga di comando di .NET.

Per eseguire l'applicazione, il comando dotnet run risolve le dipendenze dell'applicazione esterne al runtime condiviso dalla cache NuGet. È consigliabile non per usare dotnet run per eseguire le applicazioni nell'ambiente di produzione perché questo comando usa dipendenze memorizzate nella cache. In alternativa, creare una distribuzione usando il comando dotnet publish e distribuire l'output pubblicato.

Ripristino implicito

Non è necessario eseguire dotnet restore perché viene eseguito in modo implicito da tutti i comandi che richiedono un ripristino, ad esempio dotnet new, dotnet build, dotnet run, dotnet test, dotnet publish e dotnet pack. Per disabilitare il ripristino implicito, usare l'opzione --no-restore.

Il comando dotnet restore è ancora utile in alcuni scenari in cui ha senso eseguire un ripristino esplicito, ad esempio le compilazioni di integrazione continua in Azure DevOps Services o in sistemi di compilazione che richiedono il controllo esplicito quando viene eseguito il ripristino.

Per informazioni su come gestire i feed NuGet, vedere la dotnet restore documentazione.

Questo comando supporta le opzioni dotnet restore passate nel formato continuo (ad esempio, --source). Le opzioni in formato breve, come -s, non sono supportate.

Download del manifesto del carico di lavoro

Quando si esegue questo comando, avvia un download in background asincrono dei manifesti pubblicitari per i carichi di lavoro. Se il download è ancora in esecuzione al termine di questo comando, il download viene arrestato. Per altre informazioni, vedere Manifesti pubblicitari.

Arguments

<applicationArguments>

Argomenti passati all'applicazione in esecuzione.

Tutti gli argomenti non riconosciuti da dotnet run vengono passati all'applicazione. Per separare gli argomenti per dotnet run dagli argomenti per l'applicazione, usare l'opzione -- .

Opzioni

  • --

    Delimita gli argomenti a dotnet run dagli argomenti per l'applicazione in esecuzione. Tutti gli argomenti dopo questo delimitatore vengono passati all'applicazione in esecuzione.

  • -a|--arch <ARCHITECTURE>

    Specifica l'architettura di destinazione. Si tratta di una sintassi abbreviata per l'impostazione dell'identificatore di runtime (RID), in cui il valore fornito viene combinato con il RID predefinito. Ad esempio, in un computer win-x64, specificando --arch x86 si imposta il RID su win-x86. Se si usa questa opzione, non usare l'opzione -r|--runtime. Disponibile a partire da .NET 6 Preview 7.

  • --artifacts-path <ARTIFACTS_DIR>

    Tutti i file di output di compilazione del comando eseguito verranno inseriti nelle sottocartelle nel percorso specificato, separati dal progetto. Per altre informazioni, vedere layout di output artefatti. Disponibile a partire da .NET 8 SDK.

  • -c|--configuration <CONFIGURATION>

    Definisce la configurazione di compilazione. Il valore predefinito per la maggior parte dei progetti è Debug, ma è possibile eseguire l'override delle impostazioni di configurazione della compilazione nel progetto.

  • --disable-build-servers

    Forza il comando a ignorare tutti i server di compilazione permanenti. Questa opzione consente di disabilitare in modo coerente l'uso della memorizzazione nella cache di compilazione, che forza una compilazione da zero. Una compilazione che non si basa sulle cache è utile quando le cache potrebbero essere danneggiate o errate per qualche motivo. Disponibile a partire da .NET 7 SDK.

  • -e|--environment <KEY=VALUE>

    Imposta la variabile di ambiente specificata nel processo che verrà eseguita dal comando . La variabile di ambiente specificata non viene applicata al dotnet run processo.

    Le variabili di ambiente passate tramite questa opzione hanno la precedenza sulle variabili di ambiente, sulle direttive System.CommandLine env e environmentVariables dal profilo di avvio scelto. Per altre informazioni, vedere Variabili di ambiente.

    Questa opzione è stata aggiunta in .NET SDK 9.0.200.

  • -f|--framework <FRAMEWORK>

    Compila ed esegue l'app usando il framework specificato. Il framework deve essere specificato nel file di progetto.

  • --file <FILE_PATH>

    Percorso dell'app basata su file da eseguire. Se non viene specificato un percorso, la directory corrente viene usata per trovare ed eseguire il file. Per altre informazioni sulle app basate su file, vedere Creare app C# basate su file.

    In Unix è possibile eseguire direttamente le app basate su file usando il nome del file di origine nella riga di dotnet runcomando anziché . Verificare prima di tutto che il file disponga delle autorizzazioni di esecuzione. Aggiungere quindi una riga #! shebang come prima riga del file, ad esempio:

    #!/usr/bin/env dotnet run

    È quindi possibile eseguire il file direttamente dalla riga di comando:

    ./ConsoleApp.cs

    Introdotto in .NET SDK 10.0.100.

  • --force

    Forza la risoluzione di tutte le dipendenze, anche se l'ultimo ripristino ha avuto esito positivo. La specifica di questo flag equivale all'eliminazione del file project.assets.json.

  • --interactive

    Consente al comando di arrestarsi e attendere l'input o l'azione dell'utente, ad esempio il completamento dell'autenticazione.

  • --launch-profile <NAME>

    Il nome del profilo di avvio, se presente, da usare all'avvio dell'applicazione. I profili di avvio vengono definiti nel file launchSettings.json e in genere vengono denominati Development, Staging e Production. Per altre informazioni, vedere Working with multiple environments (Utilizzo con più ambienti).

  • --no-build

    Non compila il progetto prima dell'esecuzione. Imposta anche in modo implicito il flag --no-restore.

  • --no-cache

    Ignorare i controlli aggiornati e compilare sempre il programma prima dell'esecuzione.

  • --no-dependencies

    Durante il ripristino di un progetto con riferimenti da progetto a progetto, ripristina il progetto radice e non i riferimenti.

  • --no-launch-profile

    Non tenta di usare launchSettings.json per configurare l'applicazione.

  • --no-restore

    Non esegue un ripristino implicito quando si esegue il comando.

  • --no-self-contained

    Pubblicare l'applicazione come applicazione dipendente dal framework. Per eseguire l'applicazione, è necessario installare un runtime .NET compatibile nel computer di destinazione.

  • --os <OS>

    Specifica il sistema operativo di destinazione. Si tratta di una sintassi abbreviata per l'impostazione dell'identificatore di runtime (RID), in cui il valore fornito viene combinato con il RID predefinito. Ad esempio, in un computer win-x64, specificando --os linux si imposta il RID su linux-x64. Se si usa questa opzione, non usare l'opzione -r|--runtime. Disponibile a partire da .NET 6.

  • --project <PATH>

    Specifica il percorso del file di progetto da eseguire: nome della cartella o percorso completo. Se non specificato, per impostazione predefinita il percorso corrisponde alla directory corrente.

    L'abbreviazione -p di --project è deprecata a partire da .NET 6 SDK. Per un periodo di tempo limitato, -p può comunque essere usato per --project nonostante l'avviso di deprecazione. Se l'argomento fornito per l'opzione non contiene =, il comando accetta -p come breve per --project. In caso contrario, il comando presuppone che -p sia breve per --property. Questo uso flessibile di -p per --project verrà eliminato gradualmente in .NET 7.

  • --property:<NAME>=<VALUE>

    Imposta una o più proprietà di MSBuild. Specificare più proprietà delimitate da punti e virgola o ripetendo l'opzione:

    --property:<NAME1>=<VALUE1>;<NAME2>=<VALUE2>
--property:<NAME1>=<VALUE1> --property:<NAME2>=<VALUE2>

    Il formato -p breve può essere usato per --property. Se l'argomento fornito per l'opzione contiene =, -p viene accettato come breve per --property. In caso contrario, il comando presuppone che -p sia breve per --project.

    Per passare --property all'applicazione anziché impostare una proprietà MSBuild, fornire l'opzione dopo il separatore di sintassi --, ad esempio:

    dotnet run -- --property name=value

  • -r|--runtime <RUNTIME_IDENTIFIER>

    Specifica il runtime di destinazione per cui ripristinare i pacchetti. Per un elenco degli identificatori di runtime (RID, Runtime Identifier), vedere il catalogo RID.

  • --sc|--self-contained

    Pubblicare il runtime .NET con l'applicazione in modo che il runtime non debba essere installato nel computer di destinazione.

  • --tl:[auto|on|off]

    Specifica se il Logger terminale deve essere usato per l'output di compilazione. Il valore predefinito è auto, che prima di abilitare la registrazione del terminale verifica l'ambiente. Prima di abilitare il nuovo logger, il controllo dell'ambiente verifica che il terminale sia in grado di usare le funzionalità di output moderne e che non utilizzi un output standard reindirizzato. on ignora il controllo dell'ambiente e abilita la registrazione del terminale. off ignora il controllo dell'ambiente e usa il logger di console predefinito.

    Terminale Logger mostra la fase di ripristino seguita dalla fase di compilazione. Durante ogni fase, i progetti che sono in corso di compilazione vengono visualizzati nella parte inferiore del terminale. Ogni progetto che compila restituisce sia la destinazione MSBuild attualmente in fase di compilazione che la quantità di tempo impiegato per tale destinazione. È possibile cercare queste informazioni per altre informazioni sulla compilazione. Al termine della compilazione di un progetto, viene scritta una singola sezione "compilazione completata" che acquisisce:

    • Il nome del progetto compilato.
    • Il framework di destinazione (se sono presenti più destinazioni).
    • Lo stato della compilazione.
    • L'output primario di tale compilazione (con collegamento ipertestuale).
    • Qualsiasi diagnostica generata per il progetto.

    Questa opzione è disponibile a partire da .NET 8.

  • -v|--verbosity <LEVEL>

    Imposta il livello di dettaglio del comando. I valori consentiti sono q[uiet], m[inimal], n[ormal], d[etailed] e diag[nostic]. Il valore predefinito è minimal. Per ulteriori informazioni, vedere LoggerVerbosity.

  • -?|-h|--help

    Stampa una descrizione di come usare il comando.

Variabili di ambiente

Esistono quattro meccanismi in base ai quali è possibile applicare le variabili di ambiente all'applicazione avviata:

  1. Variabili di ambiente del sistema operativo quando viene eseguito il comando.
  2. Direttive System.CommandLine env , ad esempio [env:key=value]. Questi si applicano all'intero dotnet run processo, non solo al progetto eseguito da dotnet run.
  3. environmentVariables dal profilo di avvio selezionato (-lp) nel file dilaunchSettings.json del progetto, se presente. Questi si applicano al progetto in esecuzione da dotnet run.
  4. -e|--environment Valori delle opzioni dell'interfaccia della riga di comando (aggiunti in .NET SDK versione 9.0.200). Questi si applicano al progetto in esecuzione da dotnet run.

L'ambiente viene costruito nello stesso ordine di questo elenco, quindi l'opzione -e|--environment ha la precedenza più alta.

Esempi

  • Eseguire il progetto nella directory corrente:

    dotnet run

  • Eseguire l'app basata su file specificata nella directory corrente:

    dotnet run --file ConsoleApp.cs

    Il supporto delle app basate su file è stato aggiunto in .NET SDK 10.0.100.

  • Eseguire il progetto specificato:

    dotnet run --project ./projects/proj1/proj1.csproj

  • Eseguire il progetto nella directory corrente, specificando la configurazione della versione:

    dotnet run --property:Configuration=Release

  • Eseguire il progetto nella directory corrente. L'argomento --help in questo esempio viene passato all'applicazione perché viene usata l'opzione -- vuota:

    dotnet run --configuration Release -- --help

  • Ripristinare dipendenze e strumenti per il progetto nella directory corrente visualizzando solo output minimo e quindi eseguire il progetto:

    dotnet run --verbosity m

  • Eseguire il progetto nella directory corrente usando il framework specificato e passare argomenti all'applicazione:

    dotnet run -f net6.0 -- arg1 arg2

    Nell'esempio seguente vengono passati tre argomenti all'applicazione. Un argomento viene passato usando -e due argomenti vengono passati dopo --:

    dotnet run -f net6.0 -arg1 -- arg2 arg3
  • Last updated on