dotnet rundotnet run

Questo articolo si applica a: ✓ .NET Core 1.x SDK e versioni successiveThis article applies to: ✓ .NET Core 1.x SDK and later versions

NameName

dotnet run: esegue il codice sorgente senza comandi espliciti di compilazione o avvio.dotnet run - Runs source code without any explicit compile or launch commands.

RiepilogoSynopsis

dotnet run [-c|--configuration] [-f|--framework] [--force] [--interactive] [--launch-profile] [--no-build] [--no-dependencies]
    [--no-launch-profile] [--no-restore] [-p|--project] [-r|--runtime] [-v|--verbosity] [[--] [application arguments]]
dotnet run [-h|--help]

DescrizioneDescription

Il comando dotnet run offre un modo pratico per eseguire l'applicazione dal codice sorgente con un solo comando.The dotnet run command provides a convenient option to run your application from the source code with one command. Questo comando è utile per lo sviluppo iterativo veloce dalla riga di comando.It's useful for fast iterative development from the command line. Il comando dipende dal comando dotnet build per compilare il codice.The command depends on the dotnet build command to build the code. I requisiti per la compilazione, ad esempio il ripristino preliminare del progetto, si applicano anche a dotnet run.Any requirements for the build, such as that the project must be restored first, apply to dotnet run as well.

I file di output vengono scritti nel percorso predefinito, ovvero bin/<configuration>/<target>.Output files are written into the default location, which is 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.For example if you have a netcoreapp2.1 application and you run dotnet run, the output is placed in bin/Debug/netcoreapp2.1. I file vengono sovrascritti in base alle esigenze.Files are overwritten as needed. I file temporanei vengono inseriti nella directory obj.Temporary files are placed in the obj directory.

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.If the project specifies multiple frameworks, executing dotnet run results in an error unless the -f|--framework <FRAMEWORK> option is used to specify the framework.

Il comando dotnet run viene usato nel contesto dei progetti e non di assembly di compilazione.The dotnet run command is used in the context of projects, not built assemblies. Se in alternativa si prova a eseguire la DLL di un'applicazione dipendente da framework, è necessario usare dotnet senza un comando.If you're trying to run a framework-dependent application DLL instead, you must use dotnet without a command. Ad esempio, per eseguire myapp.dll, usare:For example, to run myapp.dll, use:

dotnet myapp.dll

Per altre informazioni sul driver dotnet, vedere l'argomento Strumenti dell'interfaccia della riga di comando di .NET Core.For more information on the dotnet driver, see the .NET Core Command Line Tools (CLI) topic.

Per eseguire l'applicazione, il comando dotnet run risolve le dipendenze dell'applicazione esterne al runtime condiviso dalla cache NuGet.To run the application, the dotnet run command resolves the dependencies of the application that are outside of the shared runtime from the NuGet cache. È consigliabile non per usare dotnet run per eseguire le applicazioni nell'ambiente di produzione perché questo comando usa dipendenze memorizzate nella cache.Because it uses cached dependencies, it's not recommended to use dotnet run to run applications in production. In alternativa, creare una distribuzione usando il comando dotnet publish e distribuire l'output pubblicato.Instead, create a deployment using the dotnet publish command and deploy the published output.

Nota

A partire da .NET Core 2,0, non è necessario eseguire dotnet restore perché viene eseguito in modo implicito da tutti i comandi che richiedono un ripristino, ad esempio dotnet build e dotnet run.Starting with .NET Core 2.0, you don't have to run dotnet restore because it's run implicitly by all commands that require a restore to occur, such as dotnet build and dotnet run. È ancora un comando valido 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 del momento in cui viene eseguito il ripristino.It's still a valid command in certain scenarios where doing an explicit restore makes sense, such as continuous integration builds in Azure DevOps Services or in build systems that need to explicitly control the time at which the restore occurs.

Questo comando supporta anche le opzioni dotnet restore passate nel formato lungo (ad esempio, --source).This command also supports the dotnet restore options when passed in the long form (for example, --source). Le opzioni in formato breve, come -s, non sono supportate.Short form options, such as -s, are not supported.

OpzioniOptions

--

Delimita gli argomenti a dotnet run dagli argomenti per l'applicazione in esecuzione.Delimits arguments to dotnet run from arguments for the application being run. Tutti gli argomenti dopo questo delimitatore vengono passati all'applicazione in esecuzione.All arguments after this delimiter are passed to the application run.

-c|--configuration {Debug|Release}

Definisce la configurazione di compilazione.Defines the build configuration. Il valore predefinito per la maggior parte dei progetti è Debug.The default value for most projects is Debug.

-f|--framework <FRAMEWORK>

Compila ed esegue l'app usando il framework specificato.Builds and runs the app using the specified framework. Il framework deve essere specificato nel file di progetto.The framework must be specified in the project file.

--force

Forza la risoluzione di tutte le dipendenze, anche se l'ultimo ripristino ha avuto esito positivo.Forces all dependencies to be resolved even if the last restore was successful. La specifica di questo flag equivale all'eliminazione del file project.assets.json.Specifying this flag is the same as deleting the project.assets.json file.

-h|--help

Stampa una breve guida per il comando.Prints out a short help for the command.

--interactive

Consente al comando di arrestarsi e attendere l'input o l'azione dell'utente (ad esempio, il completamento dell'autenticazione).Allows the command to stop and wait for user input or action (for example, to complete authentication).

--launch-profile <NAME>

Il nome del profilo di avvio, se presente, da usare all'avvio dell'applicazione.The name of the launch profile (if any) to use when launching the application. I profili di avvio vengono definiti nel file launchSettings.json e in genere vengono denominati Development, Staging e Production.Launch profiles are defined in the launchSettings.json file and are typically called Development, Staging, and Production. Per altre informazioni, vedere Working with multiple environments (Utilizzo con più ambienti).For more information, see Working with multiple environments.

--no-build

Non compila il progetto prima dell'esecuzione.Doesn't build the project before running. Imposta anche in modo implicito il flag --no-restore.It also implicit sets the --no-restore flag.

--no-dependencies

Durante il ripristino di un progetto con riferimenti da progetto a progetto, ripristina il progetto radice e non i riferimenti.When restoring a project with project-to-project (P2P) references, restores the root project and not the references.

--no-launch-profile

Non tenta di usare launchSettings.json per configurare l'applicazione.Doesn't try to use launchSettings.json to configure the application.

--no-restore

Non esegue un ripristino implicito quando si esegue il comando.Doesn't execute an implicit restore when running the command.

-p|--project <PATH>

Specifica il percorso del file di progetto da eseguire: nome della cartella o percorso completo.Specifies the path of the project file to run (folder name or full path). Se non specificato, per impostazione predefinita il percorso corrisponde alla directory corrente.If not specified, it defaults to the current directory.

--runtime <RUNTIME_IDENTIFIER>

Specifica il runtime di destinazione per cui ripristinare i pacchetti.Specifies the target runtime to restore packages for. Per un elenco degli identificatori di runtime (RID, Runtime Identifier), vedere il catalogo RID.For a list of Runtime Identifiers (RIDs), see the RID catalog.

-v|--verbosity <LEVEL>

Imposta il livello di dettaglio del comando.Sets the verbosity level of the command. I valori consentiti sono q[uiet], m[inimal], n[ormal], d[etailed] e diag[nostic].Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].

EsempiExamples

Eseguire il progetto nella directory corrente:Run the project in the current directory:

dotnet run

Eseguire il progetto specificato:Run the specified project:

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

Eseguire il progetto nella directory corrente. L'argomento --help in questo esempio viene passato all'applicazione perché viene usata l'opzione -- vuota:Run the project in the current directory (the --help argument in this example is passed to the application, since the blank -- option is used):

dotnet run --configuration Release -- --help

Ripristinare le dipendenze e gli strumenti per il progetto nella directory corrente visualizzando solo il risultato minimo, quindi eseguire il progetto: (.NET Core SDK 2.0 e versioni successive):Restore dependencies and tools for the project in the current directory only showing minimal output and then run the project: (.NET Core SDK 2.0 and later versions):

dotnet run --verbosity m