A .NET CLI é a ferramenta de linha de comando padrão do ecossistema .NET. Por meio dela é possível criar, executar e até mesmo publicar projetos .NET utilizando apenas comandos no terminal, sem dependência de um IDE. Neste guia rápido traremos para você os principais recursos da .NET CLI, conhecimento que atualmente é fundamental para todo desenvolvedor .NET.
O que é a .NET CLI
As ferramentas de linha de comando, chamadas de CLI (Command-Line Interface), são aplicações que permitem realizar diferentes tarefas em um contexto por meio de comandos do terminal. Por não possuírem uma interface gráfica, elas são geralmente leves e oferecem a mesma experiência de uso em diferentes sistemas operacionais. Além disso, por funcionarem com base em comandos do terminal, elas podem ser usadas não apenas de forma manual, mas também como parte de fluxos automatizados, como esteiras de CI/CD.
Algumas ferramentas desse tipo muito comuns entre os desenvolvedores são o apt-get, usado para o gerenciamento de pacotes no Linux; o npm e o yarn, gerenciadores de pacotes JavaScript; as interfaces docker e kubectl, respectivamente do Docker e do Kubernetes; além daquelas que acompanham frameworks e outras ferramentas de desenvolvimento, como ng (Angular), ionic (Ionic) e nest (Nest.js).
Neste contexto, a .NET CLI é uma ferramenta multiplataforma que simplifica o ciclo de vida do desenvolvimento .NET. Ela pode ser acessada diretamente do prompt de comandos, tornando-a acessível e fácil de usar em diferentes sistemas operacionais, sem a dependência de um IDE.
Sintaxe dos comandos
A sintaxe dos comandos da .NET CLI é simples, dividida em três partes principais:
dotnet comando argumentos
- “dotnet” é o executor, ou seja, a aplicação principal;
- em seguida temos o comando específico, que indica qual ação será realizada;
- por fim, vêm os argumentos e opções que fornecem ao comando as informações necessárias para seu funcionamento. Cada comando espera argumentos diferentes, que podem ser opcionais.
Por exemplo, para criar um novo projeto de console em C#, utilizamos o comando:
dotnet new console --language C#
No comando acima:
- “dotnet” é o executor que chama a CLI do .NET.
- “new” é o comando específico que indica que queremos criar um novo projeto.
- “console” é um argumento que especifica o tipo de projeto que estamos criando, no caso, um projeto de console.
- “–language C#” é uma opção que define a linguagem de programação a ser utilizada no projeto, que neste caso é C#.
Para verificar se você possui o .NET CLI instalado, basta abrir um prompt de comando e digitar “dotnet”. Isso exibirá informações sobre a versão instalada e os comandos disponíveis.
Caso você ainda não tenha o .NET instalado, é possível obtê-lo através do site oficial da Microsoft.
Explorando os comandos básicos
Conseguindo ajuda
Sempre que precisar de ajuda com algum comando da CLI do .NET, basta adicionar “-h” ou “–help” ao final do comando para exibir informações detalhadas sobre seu uso. Por exemplo, ao digitar “dotnet new -h”, você obterá uma lista de opções e argumentos disponíveis para o comando “new”, conforme mostrado abaixo:
dotnet new -h
Este comando exibirá uma descrição do comando “new”, incluindo as diferentes opções de templates que podem ser usados (como console, mvc, classlib, etc.), além das opções e argumentos específicos que podem ser aplicados a cada template. Esta funcionalidade é extremamente útil para explorar todas as capacidades da CLI e aprender rapidamente como utilizar novos comandos e opções.
Criando um projeto
Um dos primeiros passos ao iniciar um novo projeto é criar sua estrutura básica. Com a .NET CLI, isso é feito de maneira simples e direta. Por exemplo, para criar um novo projeto de console, utilize o comando:
dotnet new console
Cada comando normalmente assume alguns valores padrão para os argumentos. Por exemplo, ao executar o comando acima será criado um projeto cujo nome é o mesmo da pasta em que ele foi executado. Por exemplo, se o terminal está aberto na pasta C:\MeuProjeto, o comando acima criará um projeto chamado MeuProjeto.csproj. Outro exemplo de valor padrão é a linguagem utilizada (C#). Caso deseje alterar, é possível informar a opção–language ou -lang.
Para saber quais templates de projeto estão disponíveis, utilize o comando abaixo:
dotnet new list
Para cada template listado, você pode obter ajuda com o argumento -h a fim de entender quais outros argumentos podem ser informados.
Gerenciando pacotes do Nuget
Na maioria dos projetos em que trabalhamos é necessário utilizar pacotes do Nuget. Com a .NET CLI você pode adicionar um pacote da seguinte forma:
dotnet add package NomeDoPacote
Este comando deve ser executado na pasta em que se encontra o csproj e adiciona a referência ao pacote especificado no arquivo de projeto e baixa a versão mais recente do pacote NuGet. Se você precisar adicionar uma versão específica de um pacote, basta especificar a versão desejada usando a opção –version ou -v.
Já para remover o pacote, basta usar o comando remove:
dotnet remove package NomeDoPacote
E à medida que o projeto cresce, é comum utilizarmos vários pacotes. Então, para listar todos os que estão instalados, basta executar:
dotnet list package
Este comando exibe uma lista de todos os pacotes instalados no projeto atual, incluindo informações sobre a versão do pacote e a origem (source) de onde o pacote foi obtido. Isso é útil para verificar rapidamente quais dependências estão sendo usadas em seu projeto.
Por fim, para garantir que todas as dependências do projeto estejam corretamente instaladas e configuradas, utilize o comando:
dotnet restore
Esse comando utiliza o NuGet.exe por trás dos panos para restaurar todas as dependências listadas no arquivo de projeto .csproj. Ele verifica os pacotes NuGet necessários e os baixa para o diretório de pacotes local do projeto, garantindo que todas as bibliotecas e ferramentas necessárias estejam disponíveis para o desenvolvimento.
Limpando e compilando o projeto
Agora para manter seu ambiente de desenvolvimento limpo e garantir que o código seja compilado corretamente, você pode utilizar os seguintes comandos:
dotnet clean
O comando “dotnet clean” remove todos os arquivos gerados pelo build anterior, incluindo os arquivos binários e de saída, mantendo apenas os arquivos essenciais do projeto. Isso é útil quando você deseja iniciar um novo build a partir do código fonte limpo.
Já para compilar o projeto, basta executar:
dotnet build
O comando “dotnet build” compila o projeto .NET atual e suas dependências. Durante o processo de compilação, ele verifica a sintaxe do código, resolve todas as referências de bibliotecas e gera os arquivos binários necessários para a execução do aplicativo. Qualquer erro ou aviso encontrado durante a compilação será exibido no prompt de comando para que você possa corrigi-los antes de prosseguir.
Executando o projeto
Uma vez que seu projeto está criado, suas dependências restauradas e compiladas com sucesso, você pode executá-lo facilmente com o comando:
dotnet run
Este comando não apenas compila o projeto se necessário, mas também inicia a aplicação .NET diretamente do código fonte. Isso é útil para testar rapidamente as funcionalidades implementadas ou verificar o comportamento do aplicativo em diferentes cenários de uso.
Ao executar o comando “dotnet run”, o console exibirá a saída gerada pela aplicação. Por exemplo, o nosso projeto de console contém um simples código que imprime “Hello, World!” na tela:
Publicando o projeto
Para preparar seu projeto para distribuição ou implantação, você pode usar o comando dotnet publish. Este comando compila o código, copia todos os arquivos necessários e gera um pacote que pode ser facilmente implantado em um servidor ou compartilhado com outros desenvolvedores. Por exemplo:
dotnet publish -c Release -o pastaDeSaida
A opção “-c Release” especifica que a compilação deve ser feita no modo Release, que é otimizado para distribuição. A opção “-o pastaDeSaida” define o diretório de saída onde os arquivos publicados serão colocados. Assim, o projeto será compilado, e os arquivos necessários serão copiados para a pasta especificada, prontos para serem implantados.
Acelere a sua carreira conosco!
Se você é Desenvolvedor .NET Júnior e quer acelerar sua carreira até nível Pleno com salário de R$7k+, ou mesmo busca a primeira vaga, conheça a Mentoria .NET Start: Clique aqui
Se é Desenvolvedor .NET Pleno ou Sênior e quer virar referência técnica em sua equipe e mercado, com salário de R$10k+, conheça a Mentoria .NET Expert: Clique aqui
Conclusão
Neste artigo exploramos as funcionalidades fundamentais da .NET Core CLI, uma ferramenta poderosa para desenvolvedores .NET que desejam maximizar sua eficiência e produtividade. Dominar as CLI não apenas simplifica tarefas cotidianas como a criação e compilação de projetos, mas também prepara você para adotar práticas avançadas como CI/CD e automação de builds.