Partilhar via

Dotnet Run

Este artigo aplica-se a: ✔️ .NET 6 SDK 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 [<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

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 driver, consulte Visão geral da dotnetCLI do .NET.

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.

Arguments

<applicationArguments>

Argumentos passados para o aplicativo que está sendo executado.

Todos os argumentos que não são reconhecidos são passados para dotnet run o aplicativo. Para separar argumentos para dotnet run argumentos para o aplicativo, use a -- opção.

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.

  • --artifacts-path <ARTIFACTS_DIR>

    Todos os arquivos de saída de compilação do comando executado irão em subpastas sob o caminho especificado, separados por projeto. Para obter mais informações, consulte Layout de saída de artefatos. Disponível desde o SDK do .NET 8.

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

  • --disable-build-servers

    Força o comando a ignorar quaisquer servidores de compilação persistentes. Essa opção fornece uma maneira consistente de desabilitar todo o uso do cache de compilação, o que força uma compilação do zero. Uma compilação que não depende de caches é útil quando os caches podem estar corrompidos ou incorretos por algum motivo. Disponível desde .NET 7 SDK.

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

    Define a variável de ambiente especificada no processo que será executado pelo comando. A variável de ambiente especificada não é aplicada ao dotnet run processo.

    As variáveis de ambiente passadas por essa opção têm precedência sobre as variáveis de ambiente ambiente, diretivas System.CommandLine env e environmentVariables do perfil de inicialização escolhido. Para obter mais informações, consulte Variáveis de ambiente.

    (Esta opção foi adicionada no .NET SDK 9.0.200.)

  • -f|--framework <FRAMEWORK>

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

  • --file <FILE_PATH>

    O caminho para o aplicativo baseado em arquivo a ser executado. Se um caminho não for especificado, o diretório atual será usado para localizar e executar o arquivo. Para obter mais informações sobre aplicativos baseados em arquivo, consulte Criar aplicativos C# baseados em arquivo.

    No Unix, você pode executar aplicativos baseados em arquivos diretamente, usando o nome do arquivo de origem na linha de comando em vez de dotnet run. Primeiro, verifique se o arquivo tem permissões de execução. Em seguida, adicione uma linha #! shebang como a primeira linha do arquivo, por exemplo:

    #!/usr/bin/env dotnet run

    Em seguida, você pode executar o arquivo diretamente da linha de comando:

    ./ConsoleApp.cs

    Introduzido no .NET SDK 10.0.100.

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

  • --interactive

    Permite que o comando pare e aguarde a entrada ou ação do usuário. Por exemplo, para concluir a autenticação.

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

    Ignore as verificações atualizadas e sempre crie o programa antes de executar.

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

  • --no-self-contained

    Publique a sua candidatura como uma aplicação dependente do framework. Um tempo de execução .NET compatível deve ser instalado na máquina de destino para executar seu aplicativo.

  • --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, -p ainda pode ser usado para --project apesar do aviso de depreciaçã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 -p será eliminado --project 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.

  • --sc|--self-contained

    Publique o tempo de execução do .NET com seu aplicativo para que o tempo de execução não precise ser instalado na máquina de destino.

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

    Especifica se o Terminal Logger deve ser usado para a saída de 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 Terminal Logger 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.

  • -?|-h|--help

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

Variáveis de ambiente

Existem quatro mecanismos pelos quais as variáveis de ambiente podem ser aplicadas ao aplicativo iniciado:

  1. Variáveis de ambiente do sistema operacional quando o comando é executado.
  2. Diretivas System.CommandLine env , como [env:key=value]. Estes aplicam-se a todo dotnet run o processo, não apenas ao projeto que está a ser gerido pela dotnet run.
  3. environmentVariables a partir do perfil de lançamento escolhido (-lp) no arquivolaunchSettings.json do projeto, se houver. Estas aplicam-se ao projeto que está a ser gerido pela dotnet run.
  4. -e|--environment Valores de opção CLI (adicionados no .NET SDK versão 9.0.200). Estas aplicam-se ao projeto que está a ser gerido pela dotnet run.

O ambiente é construído na mesma ordem que esta lista, de modo que a -e|--environment opção tem a maior precedência.

Exemplos

  • Execute o projeto no diretório atual:

    dotnet run

  • Execute o aplicativo baseado em arquivo especificado no diretório atual:

    dotnet run --file ConsoleApp.cs

    O suporte a aplicativos baseados em arquivo foi adicionado no .NET SDK 10.0.100.

  • 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

  • Execute o projeto no diretório atual usando a estrutura especificada e passe argumentos para o aplicativo:

    dotnet run -f net6.0 -- arg1 arg2

    No exemplo a seguir, três argumentos são passados para o aplicativo. Um argumento é passado usando -, e dois argumentos são passados depois de --:

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