dotnet run

  • Articolo

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

Nome

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

Riepilogo

dotnet run [-a|--arch <ARCHITECTURE>] [-c|--configuration <CONFIGURATION>]
    [-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. I requisiti per la compilazione, ad esempio il ripristino preliminare del progetto, 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 dotnet , vedere l'argomento .NET Command Line Tools (CLI).

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.

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.

  • -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.

  • -f|--framework <FRAMEWORK>

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

  • --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.

  • -?|-h|--help

    Stampa le istruzioni di utilizzo del comando.

  • --interactive

    Consente al comando di arrestarsi e attendere l'input o l'azione dell'utente, ad esempio il completamento dell'autenticazione. Disponibile a partire da .NET Core 3.0 SDK.

  • --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-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.

  • --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 a partire da .NET 6 RC1 SDK, -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.

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

    Specifica se il logger del 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.

    Il logger del terminale 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.

Esempi

  • Eseguire il progetto nella directory corrente:

    dotnet run

  • 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