C# O Comando dotnet

Até aqui você usou o dotnet para duas ou três coisas: dotnet run, dotnet new console, dotnet build. Mas ele faz muito mais: cria projetos de vários tipos, baixa pacotes, roda testes, arruma a formatação do código, recompila sozinho quando você salva um arquivo e prepara o programa para entregar. Tudo pelo mesmo comando. Nesta aula você vai conhecer o dotnet por inteiro: como ele é organizado, como pedir ajuda a ele e os comandos que você vai usar todo dia.

Você vai aprender

O formato de todo comando: dotnet comando argumentos opções.
A descobrir o que está instalado: --version, --list-sdks, --list-runtimes, --info e dotnet sdk check.
A pedir ajuda: dotnet --help e dotnet run --help.
Os comandos do dia a dia: new, build, run e clean, com as opções mais usadas (-c Release, -v q, --).
dotnet watch (recompila sozinho) e dotnet format (arruma o código).
Os erros mais comuns: o comando digitado errado, MSB1003 e MSB1011.

Todas as saídas desta aula são reais, feitas na máquina fictícia da Ana, com o .NET 10 SDK do próprio Ubuntu (10.0.112) e o Ubuntu em português: por isso a maior parte das mensagens sai traduzida. Na sua máquina, os números de versão e os tempos podem ser outros. Os comandos rodam no terminal, não no editor do guia (veja Instalar no Linux).

A ideia: um controle remoto universal

Imagine um controle remoto que liga a TV, o som e o ar-condicionado. São aparelhos diferentes, mas você usa sempre o mesmo controle: escolhe o aparelho e aperta o botão. O dotnet é esse controle. Ele não compila nada sozinho: ele é um porteiro (o nome técnico é driver, "condutor") que recebe o seu pedido e chama a ferramenta certa:

Você digita	O `dotnet` chama
`dotnet build`	O MSBuild, o "construtor" de projetos, que chama o compilador de C# (o Roslyn).
`dotnet new`	O sistema de modelos, que copia os arquivos de um projeto novo.
`dotnet package add`	O NuGet, que baixa bibliotecas da internet (veja Pacotes NuGet).
`dotnet test`	O executor de testes (veja Testes).
`dotnet Programa.dll`	O runtime, que roda um programa já compilado (veja .NET: SDK, Runtime e CLR).

Por isso o dotnet também é chamado de CLI do .NET (de Command-Line Interface, "interface de linha de comando").

1. O formato de um comando

Todo comando do dotnet tem as mesmas partes, sempre nesta ordem:

$ dotnet build -c Release
«dotnet = o programa · build = o comando · -c Release = uma opção com o seu valor»

dotnet: O programa (o "controle remoto").
comando: O que fazer: new, build, run, test… Alguns têm subcomandos: dotnet new list, dotnet package add, dotnet sdk check.
argumentos: Sobre o que fazer, sem traço na frente: em dotnet new console, o console é o argumento (o modelo).
opções: Como fazer. Começam com traço: um traço e uma letra (-c, -o, -v) ou dois traços e uma palavra (--configuration, --output, --verbosity). São a mesma coisa: -c Release = --configuration Release.

Sem comando, o dotnet só lembra o básico (esta parte não foi traduzida no Ubuntu):

$ dotnet

Usage: dotnet [path-to-application]
Usage: dotnet [commands]

path-to-application:
  The path to an application .dll file to execute.

commands:
  -h|--help                         Display help.
  --info                            Display .NET information.
  --list-runtimes [--arch <arch>]   Display the installed runtimes matching the host or specified architecture. Example architectures: arm64, x64, x86.
  --list-sdks [--arch <arch>]       Display the installed SDKs matching the host or specified architecture. Example architectures: arm64, x64, x86.

2. O que está instalado

Antes de pedir ajuda num fórum, a primeira pergunta é sempre "qual versão você tem?". Quatro comandos respondem:

$ dotnet --version
10.0.112
$ dotnet --list-sdks
10.0.112 [/usr/lib/dotnet/sdk]
$ dotnet --list-runtimes
Microsoft.AspNetCore.App 10.0.12 [/usr/lib/dotnet/shared/Microsoft.AspNetCore.App]
Microsoft.NETCore.App 10.0.12 [/usr/lib/dotnet/shared/Microsoft.NETCore.App]

dotnet --version: A versão do SDK em uso: o kit para criar programas (compilador, modelos, MSBuild). 10.0.1xx é a primeira "faixa" de SDKs do .NET 10.
dotnet --list-sdks: Todos os SDKs instalados e a pasta de cada um. Dá para ter vários lado a lado.
dotnet --list-runtimes: Os runtimes: o que é preciso para rodar programas. Microsoft.NETCore.App roda programas de console; Microsoft.AspNetCore.App, sites e APIs. Repare que o runtime é 10.0.12 e o SDK, 10.0.112: são numerações separadas.

Tudo de uma vez: `dotnet --info`

$ dotnet --info
.NET SDK:
 Version:           10.0.112
 Commit:            95017c711e
 Workload version:  10.0.100-manifests.63b36e85
 MSBuild version:   18.0.11+95017c711

Ambiente de runtime:
 OS Name:     ubuntu
 OS Version:  26.04
 OS Platform: Linux
 RID:         ubuntu.26.04-x64
 Base Path:   /usr/lib/dotnet/sdk/10.0.112/
«… as cargas de trabalho e as listas de SDKs e runtimes de novo …»
Environment variables:
  DOTNET_CLI_TELEMETRY_OPTOUT              [1]

global.json file:
  Not found
«… dois endereços da Microsoft …»

MSBuild version: 18.0.11: A versão do MSBuild, que o dotnet build usa por baixo.
RID: ubuntu.26.04-x64: O Runtime Identifier ("identificador do ambiente"): o sistema e o processador. Ele volta na aula Publicar o Programa, onde você escolhe o RID linux-x64.
DOTNET_CLI_TELEMETRY_OPTOUT [1]: Por padrão, o dotnet manda à Microsoft dados anônimos de uso (a "telemetria"). Com essa variável de ambiente valendo 1, ele não manda. Na máquina da Ana, ela já está ligada; para ligá-la na sua, ponha a linha export DOTNET_CLI_TELEMETRY_OPTOUT=1 no fim do ~/.bashrc.
global.json file: Not found: Um global.json numa pasta prende o projeto a uma versão de SDK. Aqui não há nenhum, então vale o SDK mais novo instalado.

Está atualizado? `dotnet sdk check`

$ dotnet sdk check
SDKs do .NET:
Versão        Status
-------------------------
10.0.112      Atualizado.

Runtimes do .NET:
Nome                          Versão       Status
------------------------------------------------------
Microsoft.AspNetCore.App      10.0.12      Atualizado.
Microsoft.NETCore.App         10.0.12      Atualizado.


As últimas versões do .NET podem ser instaladas de https://aka.ms/dotnet-core-download. Para obter mais informações sobre os ciclos de vida do .NET, confira https://aka.ms/dotnet-core-support.

Ele consulta a internet e compara com as versões mais novas. No Ubuntu, a atualização vem pelo próprio sistema (sudo apt upgrade), não pelo endereço da mensagem.

3. Pedir ajuda: `--help`

Você não precisa decorar nada: o dotnet explica a si mesmo. dotnet --help (ou -h) lista todos os comandos:

$ dotnet --help
«… as opções para rodar um .dll …»
Uso: dotnet [sdk-options] [command] [command-options] [arguments]

Execute um comando do SDK do .NET.

sdk-options:
-d|--diagnostics Habilitar saída de diagnóstico.
-h|--help Mostrar a ajuda da linha de comando.
--info Exiba informações do .NET.
--list-runtimes Exiba os runtimes instalados.
--list-sdks Exiba os SDKs instalados.
--version Exiba a versão do SDK do .NET em uso.

Comandos do SDK:
build Criar um projeto do .NET.
build-server Interagir com servidores iniciados por um build.
clean Limpar as saídas do build de um projeto do .NET.
format Aplicar preferências de estilo a um projeto ou solução.
help Abre a página de referência em um navegador para o comando especificado.
msbuild Executar comandos do MSBuild (Microsoft Build Engine).
new Criar um novo projeto ou arquivo do .NET.
nuget Fornece comandos adicionais do NuGet.
pack Criar um pacote do NuGet.
package Pesquise, adicione, remova ou liste PackageReferences para um projeto do .NET.
publish Publicar um projeto do .NET para implantação.
reference Adicione, remova ou liste ProjectReferences para um projeto do .NET.
restore Restaurar as dependências especificadas em um projeto do .NET.
run Criar e executar uma saída de projeto do .NET.
sdk Gerencie a instalação do SDK do .NET.
solution Modificar os arquivos da solução do Visual Studio.
store Armazenar os assemblies especificados no repositório de pacotes do runtime.
test Executar testes de unidade usando o executor de testes especificado em um projeto do .NET.
tool Instalar ou gerenciar ferramentas que ampliam a experiência do .NET.
vstest Executar comandos do VSTest (Microsoft Test Engine).
workload Gerenciar as cargas de trabalho opcionais.

Comandos adicionais de ferramentas em pacote:
dev-certs Crie e gerencie certificados de desenvolvimento.
fsi Iniciar F# Interativo / executar scripts do F#.
user-jwts Gerenciar tokens da Web JSON em desenvolvimento.
user-secrets Gerencie segredos do usuário de desenvolvimento.
watch Inicie um observador de arquivo que executa um comando quando os arquivos são alterados.

Execute 'dotnet [command] --help' para obter mais informações sobre um comando.

A última linha é a dica mais útil: cada comando tem a sua própria ajuda. Um pedaço da ajuda do run:

$ dotnet run --help
Description:
  Comando Run do .NET

Uso:
  dotnet run [<applicationArguments>...] [options]

Argumentos:
  <applicationArguments>  Arguments passed to the application that is being
                          run. []

Opções:
  -c, --configuration <CONFIGURATION>     A configuração para a qual a execução
                                          ocorrerá. O padrão para a maioria dos
                                          projetos é 'Debug'.
«…»
  --project <PROJECT_PATH>                The path to the project file to run
                                          (defaults to the current directory if
                                          there is only one project).
  --file <FILE_PATH>                      O caminho para o aplicativo baseado
                                          em arquivo a ser executado (também
                                          pode ser passado como o primeiro
                                          argumento se não houver nenhum
                                          projeto no diretório atual).
«…»
  --no-build                              Não compile o projeto antes de
                                          executar. Implica em --no-restore.
                                          [default: False]
«…»
  -v, -verbosity <LEVEL>                  Definir o nível de detalhamento do
                                          MSBuild. Os valores permitidos são
                                          q[uiet], m[inimal], n[ormal],
                                          d[etailed] e diag[nostic].
«…»
  -?, -h, --help                          Mostrar a ajuda da linha de comando.

Leia a ajuda assim: o que está entre < > você troca por um valor seu (<CONFIGURATION> vira Release); o que está entre [ ] é opcional; ... quer dizer "pode repetir". A tradução está pela metade (algumas linhas ainda vêm em inglês), o que é normal.

Mais detalhes: dotnet help build abre no navegador a página da documentação oficial do comando (em learn.microsoft.com), com exemplos.

4. Os comandos do dia a dia

`dotnet new`: criar a partir de um modelo

O dotnet new cria projetos (e arquivos soltos) a partir de modelos (em inglês, templates). Para ver todos, dotnet new list. A lista do SDK da Ana tem 46 modelos; aqui estão os que este guia usa:

$ dotnet new list
Esses modelos correspondem à sua entrada:

Nome do modelo                                          Nome Curto                    Idioma      Tags
------------------------------------------------------  ----------------------------  ----------  ----------------------------------
«…»
Aplicativo do Console                                   console                       [C#],F#,VB  Common/Console
«…»
Arquivo de Solução                                      sln,solution                              Solution
«…»
Biblioteca de Classes                                   classlib                      [C#],F#,VB  Common/Library
«…»
arquivo de dotnet gitignore                             gitignore,.gitignore                      Config
«…»
Projeto de Teste xUnit                                  xunit                         [C#],F#,VB  Test/xUnit/Desktop/Web
«…»

Nome do modelo: O nome por extenso, em português.
Nome Curto: O que você digita: dotnet new console, dotnet new classlib, dotnet new xunit, dotnet new sln.
Idioma: As linguagens do modelo. A que está entre colchetes, [C#], é a padrão. O .NET também tem F# e Visual Basic.
Tags: Etiquetas para procurar: Test, Web, Console.

A opção -o (output, "saída") escolhe a pasta, e o nome do projeto vem dela (veja Projetos):

$ dotnet new console -o Saudacao
O modelo "Aplicativo do Console" foi criado com êxito.

Processando ações pós-criação...
Restaurando /home/ana/projetos/Saudacao/Saudacao.csproj:
  Determinando os projetos a serem restaurados...
  /home/ana/projetos/Saudacao/Saudacao.csproj restaurado (em 105 ms).
A restauração foi bem-sucedida.

"Restaurar" é baixar (ou conferir) os pacotes de que o projeto precisa. Os comandos build, run e test já restauram sozinhos; o dotnet restore existe para quando você quer só essa etapa.

`dotnet run` e os argumentos

A Ana trocou o Program.cs do projeto Saudacao para cumprimentar quem for passado na linha de comando (veja Argumentos da Linha de Comando):

Console.WriteLine($"Recebi {args.Length} argumento(s).");
foreach (string a in args)
{
    Console.WriteLine($"Olá, {a}!");
}

$ dotnet run -- Ana Beto
Recebi 2 argumento(s).
Olá, Ana!
Olá, Beto!
$ dotnet run Ana Beto
Recebi 2 argumento(s).
Olá, Ana!
Olá, Beto!
$ dotnet run -- --help
Recebi 1 argumento(s).
Olá, --help!

dotnet run -- Ana Beto: O -- (dois traços sozinhos) é uma divisória: o que vem antes é para o dotnet; o que vem depois vai inteiro para o seu programa, em args.
dotnet run Ana Beto: Sem o -- também funcionou: o dotnet run passa adiante os argumentos que ele não reconhece.
dotnet run -- --help: Aqui o -- faz diferença. Sem ele, dotnet run --help mostraria a ajuda do dotnet run (seção 3). Com ele, o --help chegou ao programa da Ana. Regra simples: use sempre o -- antes dos argumentos do seu programa.

Missão: esta caixa roda o programa como dotnet run -- Ana Beto Carla. Por enquanto ele só conta os argumentos. Acrescente o foreach que mostra Olá, NOME! para cada um, como no Program.cs acima. A saída tem de ter Olá, Carla!.

Console.WriteLine($"Recebi {args.Length} argumento(s).");

Console.WriteLine($"Recebi {args.Length} argumento(s).");
foreach (string a in args)
{
    Console.WriteLine($"Olá, {a}!");
}

`dotnet build`: Debug, Release e o volume da conversa

Por padrão, o dotnet build compila na configuração Debug: sem otimizações, bom para depurar (veja Depuração). Para a versão final, use -c Release:

$ dotnet build -c Release
  Determinando os projetos a serem restaurados...
  Todos os projetos estão atualizados para restauração.
  Saudacao -> /home/ana/projetos/Saudacao/bin/Release/net10.0/Saudacao.dll

Compilação com êxito.
    0 Aviso(s)
    0 Erro(s)

Tempo Decorrido 00:00:01.43
$ ls bin
Debug
Release

Cada configuração tem a sua pasta dentro de bin. A opção -v (verbosity, "quanto falar") muda o volume da saída: q (quiet, quieto), m (mínimo, o padrão), n (normal), d (detalhado) e diag (diagnóstico, centenas de linhas):

$ dotnet build -v q

Compilação com êxito.
    0 Aviso(s)
    0 Erro(s)

Tempo Decorrido 00:00:01.25

`dotnet clean`: apagar o que foi compilado

$ dotnet clean
Compilação de 17/10/2026 12:48:34 iniciada.
     1>Projeto "/home/ana/projetos/Saudacao/Saudacao.csproj" no nó 1 (Clean destino(s)).
     1>CoreClean:
         Excluindo o arquivo "/home/ana/projetos/Saudacao/bin/Debug/net10.0/Saudacao".
         Excluindo o arquivo "/home/ana/projetos/Saudacao/bin/Debug/net10.0/Saudacao.deps.json".
         Excluindo o arquivo "/home/ana/projetos/Saudacao/bin/Debug/net10.0/Saudacao.runtimeconfig.json".
         Excluindo o arquivo "/home/ana/projetos/Saudacao/bin/Debug/net10.0/Saudacao.dll".
         Excluindo o arquivo "/home/ana/projetos/Saudacao/bin/Debug/net10.0/Saudacao.pdb".
«… mais 9 arquivos dentro de obj/Debug …»
     1>Projeto de compilação pronto "/home/ana/projetos/Saudacao/Saudacao.csproj" (Clean destino(s)).

Compilação com êxito.
    0 Aviso(s)
    0 Erro(s)

Tempo Decorrido 00:00:00.55
$ ls bin/Debug/net10.0
«nada: a pasta ficou vazia»

O clean apaga só os arquivos da configuração Debug (para a Release: dotnet clean -c Release) e deixa as pastas vazias. Use-o quando o projeto se comportar de um jeito estranho depois de muitas mudanças: o próximo build recompila tudo do zero. Para apagar tudo, o jeito mais direto é rm -r bin obj.

5. `dotnet watch`: recompila sozinho

Enquanto você está escrevendo, salvar o arquivo e digitar dotnet run de novo cansa. O dotnet watch run ("vigie e rode") fica de olho nos arquivos do projeto e roda o programa de novo a cada vez que você salva. A Ana deixou o watch rodando e, 12 segundos depois, trocou Olá por Oi no Program.cs e salvou:

$ dotnet watch run -- Ana
dotnet watch 🔥 Hot reload enabled. For a list of supported edits, see https://aka.ms/dotnet/hot-reload.
dotnet watch 💡 Press Ctrl+R to restart.
dotnet watch 🔨 Building /home/ana/projetos/Saudacao/Saudacao.csproj ...
dotnet watch 🔨 Build succeeded: /home/ana/projetos/Saudacao/Saudacao.csproj
Recebi 1 argumento(s).
Olá, Ana!
dotnet watch ⌚ [Saudacao (net10.0)] Exited
dotnet watch ⏳ Waiting for a file to change before restarting ...
«aqui a Ana salvou o Program.cs com "Oi"»
dotnet watch 🔨 Building /home/ana/projetos/Saudacao/Saudacao.csproj ...
dotnet watch 🔨 Build succeeded: /home/ana/projetos/Saudacao/Saudacao.csproj
Recebi 1 argumento(s).
Oi, Ana!
dotnet watch ⌚ [Saudacao (net10.0)] Exited
dotnet watch ⏳ Waiting for a file to change before restarting ...
«aqui a Ana apertou Ctrl+C»
dotnet watch 🛑 Shutdown requested. Press Ctrl+C again to force exit.

Hot reload enabled: "Recarga a quente ligada": em programas que ficam abertos (um site, um jogo), o watch aplica algumas mudanças sem reiniciar o programa.
Exited / Waiting for a file to change: O programa da Ana terminou ("saiu"), e o watch ficou esperando uma mudança num arquivo.
Building … Build succeeded: Ao salvar, ele recompilou e rodou de novo, já com Oi.
Shutdown requested: Ctrl+C encerra o watch. As mensagens dele vêm em inglês e com pequenos desenhos (emojis) que o terminal do Ubuntu mostra coloridos.

6. `dotnet format`: arrumar o código

O dotnet format arruma espaços, recuos e chaves de todos os arquivos do projeto, no estilo padrão do C# (veja Sintaxe). A Ana escreveu um arquivo com pressa:

static class Feio {
public static int   Dobro( int x ){return x*2;}
}

Com --verify-no-changes ("confira, sem mudar nada"), ele só aponta o que mudaria:

$ dotnet format --verify-no-changes; echo "código de saída: $?"
/home/ana/projetos/Saudacao/Feio.cs(1,18): error WHITESPACE: Corrigir a formatação de espaço em branco. Substituir 1 caracteres por '\n'. [/home/ana/projetos/Saudacao/Saudacao.csproj]
/home/ana/projetos/Saudacao/Feio.cs(2,1): error WHITESPACE: Corrigir a formatação de espaço em branco. Inserir "\s\s\s\s". [/home/ana/projetos/Saudacao/Saudacao.csproj]
/home/ana/projetos/Saudacao/Feio.cs(2,19): error WHITESPACE: Corrigir a formatação de espaço em branco. Excluir 2 caracteres. [/home/ana/projetos/Saudacao/Saudacao.csproj]
«… mais 7 linhas parecidas …»
código de saída: 2

Cada linha diz o arquivo, a posição (linha, coluna) e o conserto: "substituir por \n" é quebrar a linha; \s\s\s\s são 4 espaços de recuo. O código de saída 2 quer dizer "há o que arrumar". Sem a opção, ele arruma de verdade, em silêncio:

$ dotnet format
$ cat Feio.cs
static class Feio
{
    public static int Dobro(int x) { return x * 2; }
}
$ dotnet format --verify-no-changes; echo "código de saída: $?"
código de saída: 0

Equipes costumam rodar o dotnet format --verify-no-changes automaticamente antes de aceitar uma mudança no código: se ele sair com código diferente de 0, alguém esqueceu de formatar.

Mapa: qual comando para quê

Quero…	Comando	Aula
Rodar um arquivo `.cs` solto	`dotnet run ola.cs`	Rodar com dotnet run
Criar um projeto	`dotnet new console -o Nome`	Projetos
Compilar / rodar / limpar	`dotnet build` / `dotnet run` / `dotnet clean`	esta aula
Mudar as configurações do projeto	editar o `.csproj`	O Arquivo .csproj
Usar uma biblioteca da internet	`dotnet package add Nome`	Pacotes NuGet
Juntar vários projetos	`dotnet new sln`, `dotnet sln add`	Soluções
Um projeto usar o outro	`dotnet reference add`	Bibliotecas de Classes
Rodar os testes	`dotnet test`	Testes
Preparar para entregar	`dotnet publish -c Release`	Publicar o Programa

Ordem antiga × ordem nova. No .NET 10, os comandos começam pelo assunto: dotnet package add, dotnet reference add. Muitos tutoriais (e o .NET 8) usam a ordem antiga, dotnet add package e dotnet add reference. As duas funcionam no .NET 10.

Quando dá errado

Comando digitado errado: Não foi possível executar porque o comando ou arquivo especificado não foi encontrado.

$ dotnet biuld
Não foi possível executar porque o comando ou arquivo especificado não foi encontrado.
Os possíveis motivos para isso incluem:
  * Você digitou incorretamente um comando dotnet interno.
  * Você pretendia executar um programa .NET, mas dotnet-biuld não existe.
  * Você pretendia executar uma ferramenta global, mas não foi possível encontrar um executável com prefixo dotnet com esse nome no PATH.

O que aconteceu: biuld não é um comando. Como o dotnet aceita ferramentas extras (instaladas com dotnet tool), ele também procurou um programa chamado dotnet-biuld, e não achou.

Como resolver: confira a grafia com dotnet --help.

Modelo digitado errado: Nenhum modelo ou subcomando encontrado correspondente

$ dotnet new consle
Nenhum modelo ou subcomando encontrado correspondente: 'consle'.
Você quis dizer um dos seguintes modelos?
   dotnet new console

Para listar modelos instalados semelhantes a 'consle', execute:
   dotnet new list consle
Para pesquisar os modelos no NuGet.org, execute:
   dotnet new search consle


Para obter detalhes sobre o código de saída, consulte https://aka.ms/templating-exit-codes#103

O que aconteceu e como resolver: aqui o dotnet é mais esperto e já sugere o certo: dotnet new console.

Não foi possível localizar um projeto para executar e error MSB1003

$ dotnet run
Não foi possível localizar um projeto para executar. Verifique se existe um projeto em /home/ana ou passe o caminho para o projeto usando --project.
$ dotnet build
MSBUILD : error MSB1003: Especifique um arquivo de solução ou de projeto. O diretório de trabalho atual não contém um arquivo de solução ou de projeto.

O que aconteceu: a Ana estava na pasta pessoal (~), que não tem nenhum .csproj. Os comandos run, build, test e clean procuram o projeto na pasta atual.

Como resolver: entre na pasta do projeto (cd ~/projetos/Saudacao) ou diga onde ele está: dotnet run --project ~/projetos/Saudacao. Para um arquivo solto, dê o nome dele: dotnet run ola.cs.

error MSB1011: Especifique o arquivo de solução ou de projeto a usar porque esta pasta contém mais de um arquivo de solução ou de projeto.

$ cp Saudacao.csproj Outro.csproj
$ dotnet build
MSBUILD : error MSB1011: Especifique o arquivo de solução ou de projeto a usar porque esta pasta contém mais de um arquivo de solução ou de projeto.

O que aconteceu: a pasta tem dois .csproj (ou um .csproj e uma solução .slnx), e o dotnet não sabe qual usar.

Como resolver: diga o nome: dotnet build Saudacao.csproj. Melhor ainda: cada projeto na sua própria pasta (veja Soluções e Vários Projetos).

A criação deste modelo fará alterações nos arquivos existentes

$ dotnet new console -o .
A criação deste modelo fará alterações nos arquivos existentes:
  Sobrescrever   Saudacao.csproj
  Sobrescrever   Program.cs

Para criar o modelo mesmo assim, execute o comando com a opção “--force”:
   dotnet new console -o . --force


Para obter detalhes sobre o código de saída, consulte https://aka.ms/templating-exit-codes#73

O que aconteceu: já existe um projeto ali, e o dotnet new se recusou a apagar o seu Program.cs. Ainda bem.

Como resolver: crie o projeto novo numa pasta nova (dotnet new console -o OutroNome). Só use --force se quiser mesmo perder os arquivos.

Referência rápida

Comando	O que faz
`dotnet --version`	Versão do SDK em uso.
`dotnet --list-sdks` / `--list-runtimes`	SDKs / runtimes instalados.
`dotnet --info`	Tudo sobre a instalação (versões, sistema, RID).
`dotnet sdk check`	Confere se há versão mais nova.
`dotnet --help` / `dotnet COMANDO --help`	Lista os comandos / a ajuda de um comando.
`dotnet new list`	Lista os modelos.
`dotnet new console -o Nome`	Cria um projeto de console na pasta `Nome`.
`dotnet restore`	Só baixa/confere os pacotes.
`dotnet build` / `-c Release`	Compila em Debug / em Release.
`dotnet build -v q`	Compila falando pouco (`q`, `m`, `n`, `d`, `diag`).
`dotnet run -- arg1 arg2`	Compila (se preciso) e roda, passando argumentos ao programa.
`dotnet run --project pasta`	Roda um projeto de outra pasta.
`dotnet clean`	Apaga o que foi compilado.
`dotnet watch run`	Roda de novo a cada arquivo salvo.
`dotnet format` / `--verify-no-changes`	Arruma a formatação / só confere.

Exercícios

1. Qual SDK?

Complete o comando que mostra só a versão do SDK em uso:

dotnet

2. Compilar para entregar

Complete o comando que compila na configuração Release:

dotnet build

3. A divisória

Complete para que o --help chegue ao programa da Ana, e não ao dotnet run:

dotnet run --help

4. Na pasta ~, a Ana digitou dotnet build e recebeu error MSB1003. O que fazer?

Reinstalar o .NET. Rodar dotnet clean primeiro. Entrar na pasta do projeto (ou usar --project). Trocar para dotnet build -c Release.

5. Qual comando roda o programa de novo sozinho a cada vez que você salva um arquivo?

dotnet run --no-build dotnet watch run dotnet format dotnet restore

6. Em dotnet new classlib -o Loja.Dados, o que é classlib?

O comando. Uma opção. O nome da pasta. O argumento: o nome curto do modelo.

Resumo

O dotnet é um porteiro: recebe o pedido e chama a ferramenta certa (MSBuild, modelos, NuGet, testes, runtime).
Formato: dotnet comando argumentos opções. Opções curtas (-c) e longas (--configuration) são a mesma coisa.
--version, --list-sdks, --list-runtimes, --info e sdk check dizem o que está instalado.
Na dúvida, dotnet --help e dotnet COMANDO --help.
build -c Release compila a versão final; run -- argumentos passa argumentos ao programa; clean apaga o que foi compilado.
watch run roda de novo a cada arquivo salvo; format arruma o código.
run, build e test procuram o projeto na pasta atual: entre nela ou use --project.

C# O Comando dotnet

A ideia: um controle remoto universal

1. O formato de um comando

2. O que está instalado

Tudo de uma vez: dotnet --info

Está atualizado? dotnet sdk check

3. Pedir ajuda: --help

4. Os comandos do dia a dia

dotnet new: criar a partir de um modelo

dotnet run e os argumentos

dotnet build: Debug, Release e o volume da conversa

dotnet clean: apagar o que foi compilado

5. dotnet watch: recompila sozinho

6. dotnet format: arrumar o código

Mapa: qual comando para quê

Quando dá errado

Referência rápida

Exercícios

1. Qual SDK?

2. Compilar para entregar

3. A divisória

Resumo

Tudo de uma vez: `dotnet --info`

Está atualizado? `dotnet sdk check`

3. Pedir ajuda: `--help`

`dotnet new`: criar a partir de um modelo

`dotnet run` e os argumentos

`dotnet build`: Debug, Release e o volume da conversa

`dotnet clean`: apagar o que foi compilado

5. `dotnet watch`: recompila sozinho

6. `dotnet format`: arrumar o código