Dotnet Run

Este artigo aplica-se a: ✔️ SDK do .NET Core 3.1 e versões posteriores

Nome

dotnet run - Executa o código-fonte sem qualquer compilação explícita ou comandos de lançamento.

Sinopse

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

Description

O dotnet run comando fornece uma opção conveniente para executar seu aplicativo a partir do código-fonte com um comando. É útil para o desenvolvimento iterativo rápido a partir da linha de comando. O comando depende do dotnet build comando para construir o código. Todos os requisitos para a compilação também se aplicam a dotnet run .

Nota

dotnet run não respeita argumentos como /property:property=value, que são respeitados pela dotnet build.

Os arquivos de saída são gravados no local padrão, que é bin/<configuration>/<target>. Por exemplo, se você tiver um netcoreapp2.1 aplicativo e executar dotnet run, a saída será colocada em bin/Debug/netcoreapp2.1. Os arquivos são substituídos conforme necessário. Os arquivos temporários são colocados no obj diretório.

Se o projeto especificar várias estruturas, a execução dotnet run resultará em um erro, a menos que a -f|--framework <FRAMEWORK> opção seja usada para especificar a estrutura.

O dotnet run comando é usado no contexto de projetos, não de montagens construídas. Se você estiver tentando executar uma DLL de aplicativo dependente da estrutura em vez disso, você deve usar dotnet sem um comando. Por exemplo, para executar myapp.dll, use:

dotnet myapp.dll

Para obter mais informações sobre o dotnet driver, consulte o tópico .NET Command Line Tools (CLI).

Para executar o aplicativo, o dotnet run comando resolve as dependências do aplicativo que estão fora do tempo de execução compartilhado do cache do NuGet. Como ele usa dependências em cache, não é recomendado usar dotnet run para executar aplicativos em produção. Em vez disso, crie uma implantação usando o dotnet publish comando e implante a saída publicada.

Restauração implícita

Você não precisa executar dotnet restore porque ele é executado implicitamente por todos os comandos que exigem uma restauração para ocorrer, como dotnet new, dotnet build, dotnet run, dotnet test, dotnet publishe dotnet pack. Para desativar a restauração implícita, use a --no-restore opção.

O dotnet restore comando ainda é útil em determinados cenários em que a restauração explícita faz sentido, como compilações de integração contínua nos Serviços de DevOps do Azure ou em sistemas de compilação que precisam controlar explicitamente quando a restauração ocorre.

Para obter informações sobre como gerenciar feeds NuGet, consulte a dotnet restore documentação.

Este comando suporta as dotnet restore opções quando passado na forma longa (por exemplo, --source). Opções de formulário curto, como -s, não são suportadas.

Downloads de manifesto de carga de trabalho

Quando você executa esse comando, ele inicia um download assíncrono em segundo plano de manifestos de publicidade para cargas de trabalho. Se o download ainda estiver em execução quando este comando terminar, o download será interrompido. Para obter mais informações, consulte Manifestos de publicidade.

Opções

• --

  Delimita argumentos a dotnet run partir de argumentos para o aplicativo que está sendo executado. Todos os argumentos após esse delimitador são passados para a execução do aplicativo.

• -a|--arch <ARCHITECTURE>

  Especifica a arquitetura de destino. Esta é uma sintaxe abreviada para definir o Runtime Identifier (RID), onde o valor fornecido é combinado com o RID padrão. Por exemplo, em uma win-x64 máquina, especificar --arch x86 define o RID como win-x86. Se você usar essa opção, não use a -r|--runtime opção. Disponível desde o .NET 6 Preview 7.

• -c|--configuration <CONFIGURATION>

  Define a configuração de compilação. O padrão para a maioria dos projetos é Debug, mas você pode substituir as definições de configuração de compilação em seu projeto.

• -f|--framework <FRAMEWORK>

  Cria e executa o aplicativo usando a estrutura especificada. A estrutura deve ser especificada no arquivo de projeto.

• --force

  Força todas as dependências a serem resolvidas, mesmo que a última restauração tenha sido bem-sucedida. Especificar esse sinalizador é o mesmo que excluir o arquivo project.assets.json .

• -?|-h|--help

  Imprime uma descrição de como usar o comando.

• --interactive

  Permite que o comando pare e aguarde a entrada ou ação do usuário. Por exemplo, para concluir a autenticação. Disponível desde o SDK do .NET Core 3.0.

• --launch-profile <NAME>

  O nome do perfil de inicialização (se houver) a ser usado ao iniciar o aplicativo. Os perfis de inicialização são definidos no arquivo launchSettings.json e normalmente são chamados Developmentde , Staginge Production. Para obter mais informações, consulte Trabalhando com vários ambientes.

• --no-build

  Não cria o projeto antes da execução. Também coloca implicitamente a --no-restore bandeira.

• --no-dependencies

  Ao restaurar um projeto com referências de projeto a projeto (P2P), restaura o projeto raiz e não as referências.

• --no-launch-profile

  Não tenta usar launchSettings.json para configurar o aplicativo.

• --no-restore

  Não executa uma restauração implícita ao executar o comando.

• --os <OS>

  Especifica o sistema operacional (SO) de destino. Esta é uma sintaxe abreviada para definir o Runtime Identifier (RID), onde o valor fornecido é combinado com o RID padrão. Por exemplo, em uma win-x64 máquina, especificar --os linux define o RID como linux-x64. Se você usar essa opção, não use a -r|--runtime opção. Disponível desde .NET 6.

• --project <PATH>

  Especifica o caminho do arquivo de projeto a ser executado (nome da pasta ou caminho completo). Se não for especificado, o padrão será o diretório atual.

  A -p abreviatura de --project é preterida a partir do SDK do .NET 6. Por um tempo limitado a partir do SDK do .NET 6 RC1, -p ainda pode ser usado para --project apesar do aviso de descontinuação. Se o argumento fornecido para a opção não contiver =, o comando aceitará -p como abreviação de --project. Caso contrário, o comando assume que -p é a abreviação de --property. Esse uso flexível do for --project será eliminado -p no .NET 7.

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

  Define uma ou mais propriedades do MSBuild. Especifique várias propriedades delimitadas por ponto-e-vírgula ou repetindo a opção:

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

  A forma -p abreviada pode ser usada para --property. Se o argumento fornecido para a opção contiver =, -p é aceite como abreviatura de --property. Caso contrário, o comando assume que -p é a abreviação de --project.

  Para passar --property para o aplicativo em vez de definir uma propriedade MSBuild, forneça a opção após o -- separador de sintaxe, por exemplo:

  dotnet run -- --property name=value
  

• -r|--runtime <RUNTIME_IDENTIFIER>

  Especifica o tempo de execução de destino para o qual restaurar pacotes. Para obter uma lista de identificadores de tempo de execução (RIDs), consulte o catálogo RID.

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

  Especifica se o registrador de terminal deve ser usado para a saída da compilação. O padrão é auto, que primeiro verifica o ambiente antes de habilitar o registro em log do terminal. A verificação de ambiente verifica se o terminal é capaz de usar recursos de saída modernos e não está usando uma saída padrão redirecionada antes de ativar o novo registrador. on ignora a verificação do ambiente e habilita o registro em log do terminal. off ignora a verificação de ambiente e usa o registrador de console padrão.

  O registrador de terminal mostra a fase de restauração seguida pela fase de compilação. Durante cada fase, os projetos atualmente em construção aparecem na parte inferior do terminal. Cada projeto que está construindo produz tanto a meta do MSBuild que está sendo criada quanto a quantidade de tempo gasto nessa meta. Você pode pesquisar essas informações para saber mais sobre a compilação. Quando um projeto termina de construir, uma única seção "construção concluída" é escrita que captura:

  • O nome do projeto construído.
  • A estrutura de destino (se multidirecionada).
  • O status dessa compilação.
  • A saída primária dessa compilação (que é hiperligada).
  • Qualquer diagnóstico gerado para esse projeto.

  Esta opção está disponível a partir do .NET 8.

• -v|--verbosity <LEVEL>

  Define o nível de detalhamento do comando. Os valores permitidos são q[uiet], m[inimal], n[ormal], d[etailed], e diag[nostic]. A predefinição é minimal. Para obter mais informações, veja LoggerVerbosity.

Exemplos

• Execute o projeto no diretório atual:

  dotnet run
  

• Execute o projeto especificado:

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

• Execute o projeto no diretório atual, especificando a configuração de versão:

  dotnet run --property:Configuration=Release
  

• Execute o projeto no diretório atual (o --help argumento neste exemplo é passado para o aplicativo, já que a opção em branco -- é usada):

  dotnet run --configuration Release -- --help
  

• Restaure dependências e ferramentas para o projeto no diretório atual mostrando apenas a saída mínima e, em seguida, execute o projeto:

  dotnet run --verbosity m