Skip to content

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]:

winget install Microsoft.DotNet.SDK.10

É 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:

> dotnet --version
10.0.112

O comando [dotnet --list-sdks] lista as versões do SDK instaladas (várias versões podem coexistir):

> dotnet --list-sdks
10.0.112 [C:\Program Files\dotnet\sdk]

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]:

// primeiro programa C#: uma aplicação de arquivo único
Console.WriteLine("1st try with C# 14 and .NET 10");

e executá-lo:

> dotnet run hello.cs
1st try with C# 14 and .NET 10

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:

1
2
3
#:package MySqlConnector@2.4.0
#:property PublishAot=false
#:sdk Microsoft.NET.Sdk.Web
  • 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:

> dotnet project convert hello.cs -o hello

O comando criou uma pasta chamada [hello] contendo uma cópia do programa e um arquivo de projeto chamado [hello.csproj]:

1
2
3
4
> dir /s /b (list of files)
hello.cs
hello/hello.cs
hello/hello.csproj
<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <PublishAot>true</PublishAot>
    <PackAsTool>true</PackAsTool>
    <UserSecretsId>hello-7b9b5da29436665281cfbf4b23ebf4fed6297358227418ac7d456d2e18d162bf</UserSecretsId>
  </PropertyGroup>

</Project>

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):

1
2
3
4
5
6
7
8
> dotnet new console -n FirstProgram
The template "Console App" was created successfully.

Processing post-creation actions...
Restoring csharp-oct-2026/02-installation/FirstProgram/FirstProgram.csproj:
  Determining projects to restore...
  Restored csharp-oct-2026/02-installation/FirstProgram/FirstProgram.csproj (in 127 ms).
Restore succeeded.

O comando criou uma pasta chamada [FirstProgram] contendo dois arquivos. O arquivo de projeto [FirstProgram.csproj] é o seguinte:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

</Project>
  • 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:

// o programa principal do projeto [FirstProgram]
Console.WriteLine("1st try with a C# 14 / .NET 10 project");

2.4.2. Compilação e execução

O comando [dotnet build], digitado na pasta do projeto, compila o projeto:

> dotnet build
  Determining projects to restore...
  All projects are up-to-date for restore.
  FirstProgram -> csharp-oct-2026/02-installation/FirstProgram/bin/Debug/net10.0/FirstProgram.dll

Build succeeded.
    0 Warning(s)
    0 Error(s)

Time Elapsed 00:00:01.56
  • 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:

1
2
3
4
5
6
> dir bin\Debug\net10.0 (list of files)
FirstProgram
FirstProgram.deps.json
FirstProgram.dll
FirstProgram.pdb
FirstProgram.runtimeconfig.json
  • [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:

> FirstProgram
1st try with a C# 14 / .NET 10 project

No entanto, o comando [dotnet run] é o mais usado; ele compila o projeto, se necessário, e em seguida o executa:

> dotnet run
1st try with a C# 14 / .NET 10 project

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]:

> dotnet new sln -n 02-installation
The template "Solution File" was created successfully.

e depois adicionar o projeto a ela:

> dotnet sln add FirstProgram
Project `FirstProgram/FirstProgram.csproj` added to the solution.

Vamos adicionar um segundo projeto, [TwoHands], cujo conteúdo veremos mais adiante:

> dotnet sln add TwoHands
Project `TwoHands/TwoHands.csproj` added to the solution.

O comando [dotnet sln list] lista os projetos da solução:

1
2
3
4
5
> dotnet sln list
Project(s)
----------
FirstProgram/FirstProgram.csproj
TwoHands/TwoHands.csproj

O arquivo de solução [02-installation.slnx] é o seguinte:

1
2
3
4
<Solution>
  <Project Path="TwoHands/TwoHands.csproj" />
  <Project Path="FirstProgram/FirstProgram.csproj" />
</Solution>

É 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]:

1
2
3
4
5
6
7
8
9
namespace TwoHands;

class P1
{
    static void Main(string[] args)
    {
        Console.WriteLine("Main of class P1");
    }
}

e a classe [P2]:

1
2
3
4
5
6
7
8
9
namespace TwoHands;

class P2
{
    static void Main(string[] args)
    {
        Console.WriteLine("Main of class P2");
    }
}

Se você compilar o projeto sem tomar nenhuma outra precaução, obterá um erro:

> dotnet build
...\TwoHands\P1.cs(5,17): error CS0017: Program has more than one entry point defined. Compile with /main to specify the type that contains the entry point. 

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]:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <!-- a classe cujo método Main é executado -->
    <StartupObject>TwoHands.P2</StartupObject>
  </PropertyGroup>

</Project>
  • Linha 9: o método [Main] que foi executado pertence à classe [TwoHands.P2] (o nome completo da classe, incluindo o namespace).

Resultados:

> dotnet run
Main of class P2

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.