2. Configuração do ambiente de desenvolvimento
Em 2008, instalávamos o Visual C# 2008 Express, que incluía o .NET Framework 3.5, o SGBD SQL Compact Server e a documentação do MSDN, e depois criávamos projetos com assistentes gráficos. Hoje, o ambiente de desenvolvimento é formado por dois componentes independentes:
- o SDK do .NET (“Software Development Kit”): o compilador, a plataforma de execução, as bibliotecas e o comando [dotnet], que permite fazer tudo pela linha de comando (criar, compilar, executar, testar e publicar um programa);
- um editor ou uma IDE (ambiente de desenvolvimento integrado): [VS Code] com a extensão [C# Dev Kit], ou o [Visual Studio 2026], ou o [JetBrains Rider]. O editor se apoia no SDK.
Este documento usa o comando [dotnet] para todas as operações: ele funciona da mesma maneira no Windows, no Linux e no macOS, qualquer que seja o editor escolhido.
2.1. SDK do .NET 10
2.1.1. Instalação
O SDK do .NET 10 pode ser baixado em https://dotnet.microsoft.com/download/dotnet/10.0. No Windows, também é possível instalá-lo a partir de um terminal (PowerShell ou prompt de comando) com o gerenciador de pacotes [winget]:
É preciso escolher o SDK (que contém tudo) e não apenas o “runtime” (que só permite executar programas já compilados). No Linux, o SDK está disponível nos repositórios das principais distribuições (por exemplo, [sudo apt install dotnet-sdk-10.0] no Ubuntu; dependendo da versão da distribuição, pode ser necessário adicionar antes o repositório indicado na documentação de instalação da Microsoft).
Depois da instalação, abra um novo terminal para verificar se o comando [dotnet] está disponível e exibe a versão do SDK:
O comando [dotnet --list-sdks] lista as versões do SDK instaladas (várias versões podem coexistir):
A versão exata (neste caso, [10.0.112]) depende da data de instalação: a Microsoft publica uma atualização corretiva todo mês. Qualquer versão 10.0.x do SDK serve para este documento. O comando [dotnet --info] fornece informações mais detalhadas (sistema operacional, localização do SDK, versões dos runtimes instalados).
2.1.2. O comando dotnet
O comando [dotnet] inclui muitos subcomandos. Estes são os que usaremos:
Comando | Função |
[dotnet run file.cs] | compila e executa um aplicativo de arquivo único |
[dotnet new console -n Name] | cria um projeto de console na pasta [Name] (outros templates: [classlib], [mstest], [web]…) |
[dotnet build] | compila o projeto da pasta atual |
[dotnet run] | compila (se necessário) e executa o projeto da pasta atual |
[dotnet test] | executa os testes unitários (Capítulo 6) |
[dotnet new sln] | cria uma solução (um arquivo que agrupa vários projetos) |
[dotnet sln add Project] | adiciona um projeto à solução |
[dotnet add package Name] | adiciona uma biblioteca NuGet ao projeto (Capítulos 10 e 11) |
[dotnet add reference ../Other] | adiciona uma referência a outro projeto (Capítulo 6) |
[dotnet publish] | prepara o programa para implantação |
As bibliotecas que não fazem parte da plataforma são distribuídas como pacotes NuGet, baixados de https://www.nuget.org e armazenados no computador na pasta [%USERPROFILE%\.nuget\packages]. Em 2008, copiávamos os arquivos DLL das bibliotecas (Spring.NET, NUnit e o conector MySQL) para uma pasta [lib] dentro do projeto; hoje, o projeto declara os pacotes de que precisa, e o comando [dotnet] os baixa.
2.2. O editor
2.2.1. VS Code
VS Code é um editor gratuito e multiplataforma. Para programar em C#, adiciona-se a extensão C# Dev Kit da Microsoft (menu “Extensions”, busque por “C# Dev Kit”), que também instala a extensão C#. Ela oferece:
- realce de sintaxe, autocompletar código e ajuda em dicas de contexto;
- detecção de erros durante a digitação;
- navegação no código (F12: Go to Definition);
- um Gerenciador de Soluções (visão “Solution Explorer”);
- execução e depuração (F5);
- execução de testes unitários (visão “Testing”).
No VS Code, abra a pasta que contém os programas (“File / Open Folder”), por exemplo, a pasta [csharp-oct-2026] com os exemplos deste documento. O terminal integrado (“Terminal / New Terminal”) permite digitar comandos [dotnet] sem sair do editor.
2.2.2. Visual Studio 2026
No Windows, você pode preferir usar o Visual Studio 2026, sucessor do Visual Studio 2008 usado no curso original. Sua edição Community é gratuita para pessoas físicas, instituições de ensino e projetos de código aberto. Instale-o em https://visualstudio.microsoft.com selecionando a carga de trabalho “.NET Desktop Development” (e “ASP.NET and web development” para o Capítulo 13). O Visual Studio abre diretamente as soluções [.slnx] e os projetos [.csproj] dos exemplos (“File / Open / Project/Solution”) e os executa com [Ctrl-F5] (sem depuração) ou [F5] (com depuração), exatamente como em 2008.
Uma terceira opção é o JetBrains Rider, gratuito para uso não comercial.
No restante deste documento, as etapas são descritas com o comando [dotnet], que produz os mesmos resultados qualquer que seja o editor.
2.3. Um primeiro programa: um aplicativo de arquivo único
2.3.1. O programa
A partir do .NET 10, um programa C# pode ser um único arquivo [.cs], sem arquivo de projeto. É o chamado "file-based app". Vamos criar o seguinte arquivo [hello.cs]:
e executá-lo:
Comentários:
- linha 1: um comentário. Tudo o que vem depois de [//] até o fim da linha é ignorado pelo compilador;
- linha 2: a única instrução do programa: ela imprime uma linha de texto na tela. O programa não tem classe nem método chamado [Main], ao contrário de seu equivalente de 2008; veremos no Capítulo 3 que o próprio compilador os gera;
- O comando [dotnet run hello.cs] compila o programa e depois o executa. A primeira execução leva alguns segundos; as execuções seguintes são quase imediatas enquanto o arquivo não for alterado, pois o resultado da compilação fica armazenado em cache.
Os aplicativos de arquivo único são adequados para programas pequenos, e os usaremos na maioria dos exemplos. Algumas diretivas, colocadas no início do arquivo, permitem criá-los sem arquivo de projeto:
- a diretiva [#:package] adiciona uma biblioteca NuGet (Capítulo 10);
- a diretiva [#:property] define uma propriedade de compilação (Capítulo 5);
- a diretiva [#:sdk] seleciona um SDK diferente, como o dos aplicativos web (Capítulo 12).
No Windows, se os arquivos [.cs] forem salvos em UTF-8 (o padrão no VS Code), os caracteres acentuados aparecem corretamente no terminal.
2.3.2. Convertendo um aplicativo de arquivo único em um projeto
Quando um aplicativo de arquivo único cresce (vários arquivos, testes, referências a outros projetos), ele é convertido em um projeto:
O comando criou uma pasta chamada [hello] contendo uma cópia do programa e um arquivo de projeto chamado [hello.csproj]:
O arquivo de projeto herda as propriedades padrão dos aplicativos de arquivo único (por exemplo, [PublishAot], que prepara a compilação antecipada em código nativo). Você pode remover as que não forem necessárias. Vamos agora examinar os projetos com mais detalhes.
2.4. Um projeto de console
2.4.1. Criação do projeto
Um projeto é uma pasta que contém um arquivo de projeto ([.csproj]) e arquivos-fonte. Ele é criado com o comando [dotnet new] seguido do nome de um template (neste caso, [console], uma aplicação de console):
O comando criou uma pasta chamada [FirstProgram] contendo dois arquivos. O arquivo de projeto [FirstProgram.csproj] é o seguinte:
- Linha 1: o projeto usa o SDK [Microsoft.NET.Sdk], o das aplicações de console e bibliotecas;
- linha 4: o projeto produz um executável ([Exe]) e não uma biblioteca;
- linha 5: a plataforma de destino é o .NET 10 ([net10.0]);
- linha 6: os namespaces mais comuns ([System], [System.IO], [System.Linq]…) são importados automaticamente em todos os arquivos (Capítulo 3);
- linha 7: o compilador verifica o uso de referências nulas e emite avisos sobre possíveis erros (Capítulos 3 e 4).
O arquivo de 2008 descrevia, em cerca de cem linhas, cada arquivo-fonte do projeto, as referências às bibliotecas e as configurações Debug/Release. O arquivo de projeto atual contém apenas as definições que diferem dos padrões: todos os arquivos [.cs] da pasta fazem parte do projeto.
Substituímos o conteúdo do arquivo [Program.cs] gerado pelo seguinte:
2.4.2. Compilação e execução
O comando [dotnet build], digitado na pasta do projeto, compila o projeto:
- Linha 2: o comando começa por restaurar o projeto, ou seja, baixar os pacotes NuGet dos quais ele depende (aqui não há nenhum);
- Linha 4: o resultado da compilação é uma DLL, o arquivo [FirstProgram.dll] colocado na pasta [bin/Debug/net10.0] do projeto. No Windows, o caminho exibido é um caminho do Windows ([bin\Debug\net10.0\FirstProgram.dll]).
A pasta [bin/Debug/net10.0] contém então os seguintes arquivos:
- [FirstProgram.dll] contém o código compilado (em código intermediário IL);
- [FirstProgram] (no Windows, [FirstProgram.exe]) é um pequeno inicializador que dá partida na plataforma .NET e a faz executar a DLL;
- [FirstProgram.pdb] contém as informações usadas pelo depurador;
- os dois arquivos [.json] descrevem as dependências do programa e a versão do .NET necessária para executá-lo.
Você pode executar o inicializador diretamente:
No entanto, o comando [dotnet run] é o mais usado; ele compila o projeto, se necessário, e em seguida o executa:
Como em 2008, existem duas configurações de build: Debug (padrão, com informações de depuração) e Release (otimizada, para produção), selecionadas com a opção [-c Release]: [dotnet build -c Release] gera o programa na pasta [bin/Release/net10.0]. A pasta [obj] contém arquivos intermediários da compilação. As pastas [bin] e [obj] podem ser apagadas sem risco: são recriadas na próxima compilação.
2.5. Uma solução com vários projetos
2.5.1. Criação da solução
Uma solução agrupa vários projetos. Ela permite abri-los juntos no editor e compilá-los juntos. Vamos criar uma solução na pasta que contém o projeto [FirstProgram]:
e depois adicionar o projeto a ela:
Vamos adicionar um segundo projeto, [TwoHands], cujo conteúdo veremos mais adiante:
O comando [dotnet sln list] lista os projetos da solução:
O arquivo de solução [02-installation.slnx] é o seguinte:
É um arquivo XML muito simples. Desde o .NET 10, esse é o formato padrão das soluções ([.slnx]). O antigo formato [.sln], usado no Visual Studio 2008, era bem mais verboso; ele ainda existe em projetos antigos, e o comando [dotnet new sln --format sln] ainda pode ser usado para criá-lo.
Na pasta da solução, o comando [dotnet build] compila todos os projetos da solução. Para executar um projeto específico, vá até a pasta dele e digite [dotnet run], ou use a opção [--project]: [dotnet run --project FirstProgram].
2.5.2. Um projeto com vários métodos Main
O curso de 2008 mostrava que um projeto pode conter várias classes, cada uma com um método estático chamado [Main], e que é preciso especificar qual deve ser executada. Isso ainda é possível. O projeto [TwoHands] contém duas classes. A classe [P1]:
e a classe [P2]:
Se você compilar o projeto sem tomar nenhuma outra precaução, obterá um erro:
O compilador não sabe qual método [Main] é o ponto de entrada do programa. Indicamos isso no arquivo de projeto com a propriedade [StartupObject]:
- Linha 9: o método [Main] que foi executado pertence à classe [TwoHands.P2] (o nome completo da classe, incluindo o namespace).
Resultados:
Com instruções de nível superior (Capítulo 3), a questão deixa de existir: um único arquivo do projeto pode contê-las, e esse arquivo serve de ponto de entrada.
2.6. Exemplos deste documento
Para executar os exemplos deste documento:
- baixe a pasta [csharp-oct-2026] (link no início do documento);
- abra-a no VS Code (“File / Open Folder”) ou, para um capítulo específico, abra a solução do capítulo ([.slnx]) no Visual Studio;
- em um terminal posicionado na pasta de um capítulo, execute um aplicativo de arquivo único com [dotnet run name.cs], ou um projeto com [dotnet run] na pasta do projeto.
Os Capítulos 10 e 11 usam um banco de dados MySQL; a instalação do MySQL com o [Laragon] é descrita no apêndice.