Muitos programadores ao construírem suas aplicações .NET em C# (ou CSharp) utilizam o Visual Studio. Ela é uma ferramenta fantástica, completa e um pouco pesada. Mas há também uma solução mais leve que funciona em vários sistemas operacionais como Linux, Mac e no Windows, claro. Ela é o Visual Studio Code. Porém utilizá-la para programar em C# pode exigir certo conhecimento de linhas de comando. Nesse artigo vamos aprender os O mínimo que precisa saber sobre dotnet CLI (.net commandline), para criar as aplicações.

Visual Studio versus Visual Studio Code

O Visual Studio é a IDE da Microsoft. Ela suporta uma grande quantidade de linguagens, mas dá especial atenção às linguagens que suportam a CLS – Common Language Specifications –, tais como as linguagens C#, F# ou até mesmo o VB.NET. Essa IDE é muito completa e profissional, mas como ela é paga nem todas as empresas conseguem utiliza-la. Porém, desenvolvedores podem baixar e instalar em suas casas para consumo próprio através de uma versão específica chamada Visual Studio Community.

Não somos especialistas em licenciamento, portanto, caso tenha dúvidas no uso prático da ferramenta, leia a documentação disponibilizada pela própria Microsoft ou procure um consultor de licenças da fabricante.

Outra opção bastante interessante é o Visual Studio Code. Embora tenha nome parecido por fazer parte da suíte de desenvolvimento da Microsoft, trata-se de uma ferramenta completamete distinta. O VSCode é construído para funcionar em Windows, Linux e Mac. Ele suporta qualquer linguagem até por que ele não se propõe a ser uma IDE. Ele se considera um editor de texto sofisticado que suporta muitos plugins. Esses plugins dão uma capacidade incrível a ferramenta. Com eles é possível desenvolver em C#, Python, Ruby, Assembly x86, Lisp, Cobol ou o que você quiser. É possível debugar, fazer deploy, integrar com o docker, gerar documentação automática, etc.

Como criar uma solução dotnet por linha de comando

Em .NET há um superpacote chamado de solution, que não está presente em qualquer outra linguagem. A solution agrega diversos projetos diferentes. Os projetos geram binários, sejam eles executáveis (.exe, por exemplo), bibliotecas (.dll) ou outros formatos específicos a depender do que se está construíndo. Portanto uma solution agrega bibliotecas. As linhas de comando a seguir mostram um pouco sobre como lidar com solutions através da cli.

# Criando uma nova solution
dotnet new sln
dotnet new sln --name <nome-da-solution>

Como já orientado acima, uma solution não faz sentido sozinha. Ela agrega diferentes projetos que possuem um significado particular para a aplicação a ser desenvolvida. O comando a seguir exibe os diversos templates de projetos nativos existentes para a construção de projetos. Note que há uma grande quantidade de opções interessantes

# Linha de comando para listar todos os templates de projeto existentes
dotnet new --list

Para fazer sentido, vamos agora criar alguns projetos para compor a solution. No exemplo optamos por fazer um modelo tradicional com projetos de Presentation, Application, Domain e Infrastructure. E assim teremos quatro pastas, sendo uma para cada projeto. A Presentation será feita utilizando Angular, a Application será feita com ASP.NET WebAPI, a Domain será uma Class Library, bem como a Infrastructure.

# Considero que o diretório atual é /src
# Criando a pasta e o projeto Presentation com Angular
mkdir Presentation
cd Presentation
dotnet new angular

# Criando a pasta e o projeto Application com WebAPI
cd ..
mkdir Application
cd Application
dotnet new webapi

# Criando a pasta e o projeto Domain com ClassLibrary
cd ..
mkdir Domain
cd Domain
dotnet new classlib

# Criando a pasta e o projeto Infrastructure com ClassLibrary
cd ..
mkdir Infrastructure
cd Infrastructure
dotnet new classlib

Como criar um arquivo gitignore pela linha de comando dotnet

Estou considerando que toda a solução em questão está utilizando o GIT. No ano de 2023 ele se tornou commodity e praticamente não há uso de outros versionadores, mas quando há estão projetando migrar para o GIT. Pois bem, o git possui um arquivo chamado .gitignore (GIT Ignore) que possui uma lista de padrões de arquivos ou diretórios que não devem ser versionados. Isso é fundamental para que dependências externas (Nuget packages, npm, etc.) ou mesmo arquivos binários (.exe, .dll) não entrem no versionamento. A linha de comando dá uma mãozinha para construção desse arquivo, mas ele pode ser editado a vontade, de acordo com as necessidades da solução.

# Linha de comando para criação do arquivo .gitignore em .NET
dotnet new gitignore

Criando relação entre projetos por linha de comando

Depois de avançarmos com a construção de uma solution e os vários projetos ainda precisamos fazer algumas coisas para finalizar o assunto. Note que os projetos não enxergam uns aos outros, ou seja, não há como o projeto de Application acessar o projeto de Domain, por exemplo. Para que isso seja possível é necessário vincula-las.

# Linha de comando que exibe todas as referências existentes
dotnet list reference

Já a linha de comando a seguir adiciona o vínculo de um projeto a outro. Vale esclarecer que essa ação pode ser feita alterando o arquivo .csproj diretamente. Muitas vezes eu prefiro ir direto no arquivo de configuração, mas fique a vontade para utilizar o que lhe parece mais adequado.

# Considere que o diretório raiz do projeto é /src

# Application referencia domain e infrastructure
dotnet add /src/application.csproj reference /Project/src/domain.csproj
dotnet add /src/application.csproj reference /Project/src/infrastructure.csproj

# Já a camada de infrastructure referencia apenas domain
dotnet add /src/infrastructure.csproj reference /Project/src/domain.csproj

Adicionando os projetos a Solution

Além de tudo o que comentamos, é necessário adicionar todos esses projetos à solution, desse modo todos compreendem a uma só estrutura.

# Esse comando deve ser rodado na pasta /src, onde está o arquivo .sln (Solution)
dotnet sln add src/Presentation
dotnet sln add src/Application
dotnet sln add src/Domain
dotnet sln add src/Infrastructure

Adicionando referencias externas para os projetos por linha de comando

Outro aspecto importante é a possibilidade de referenciar bibliotecas externas em pacotes Nuget. A vinculação segue um formato muito semelhante ao de vínculos entre projetos. Veja abaixo na prática.

# Comando para listar todos os packages instalados no projeto
dotnet list package

# Instalação do FluentValidation no projeto Domain
cd /src/domain
dotnet add package FluentValidation

# Instalação do EntityFramework no projeto Infrastructure
cd /src/infrastructure
dotnet add package EntityFramework

Como rodar a aplicação por linha de comando

Por fim há alguns comandos importantes para a execução do seu código desenvolvido. Segue uma pequena listagem prática:

# Comando que compila o projeto ou a solution
dotnet build

# Comando que compila e executa o projeto. 
dotnet run

# Comando que gera um executável, bibloteca ou outro artefato para o projeto ou solução definido
dotnet publish

# Comando que compila o código e gera um pacote .nuget
dotnet pack

# Comando que executa os códigos de teste do projeto ou solução
dotnet test

Outros comandos

Por fim separamos alguns poucos comandos que podem ser interessantes para o dia a dia.

# Comando que apaga as pastas e demais artefatos gerados pelo projeto, sejam binários, executáveis, etc.
dotnet clean

# Comando utilizado como help para a lista de comandos da .NET CLI
dotnet help

# Linha de comando que baixa todas as dependências para o projeto
dotnet restore

# Comando que lista todos os pacotes ou referências
dotnet list package
dotnet list reference

# Comando para remover uma referência ou package de um projeto
dotnet remove

# Comandos que rodam a aplicação como o dotnet run, porém observando alterações nos arquivos de código
dotnet watch 
dotnet watch run
dotnet watch test

Conclusão

Esse artigo ‘O mínimo que precisa saber sobre dotnet CLI’ traz um material muito simples e objetivo para quem não tem muita experiência com as linhas de comando do .NET CLI. Esses comandos são fundamentais para o bom entendimento da estrutura dos projetos, bem como relacioná-los, construir ou utilizar pacotes nuget, e afins. Você pode notar que alguns desses comandos podem facilmente ser substutuídos pela alteração direta dos arquivos .csproj, mas são importantes de todo modo. Além disso note como é fácil criar um .gitignore para seu projeto ao invés de ficar procurando um.