C# Instalar no Windows e macOS

O .NET é o mesmo nos três sistemas: o programa que a Ana roda no Ubuntu roda igual no Windows e no Mac. Só muda o jeito de instalar. Nesta aula você instala o .NET 10 SDK no Windows (pelo winget, pelo instalador ou junto com o Visual Studio) e no macOS (pelo instalador .pkg), abre o terminal, confere a instalação e roda o primeiro programa.

Você vai aprender

Como abrir o terminal no Windows (PowerShell) e no macOS (Terminal).
Três formas de instalar no Windows: winget, o instalador .exe e o Visual Studio 2026.
Como instalar no macOS, escolhendo entre Arm64 (chips Apple M1, M2…) e x64 (Macs com Intel).
Como conferir com dotnet --version e dotnet --info.
O que muda entre os sistemas: pastas, barras, o .exe.
Os erros mais comuns, como 'dotnet' não é reconhecido.

Telas ilustrativas

A máquina da Ana usa Linux, então as telas de Windows e de macOS desta aula não puderam ser produzidas lá: elas são ilustrativas. Os passos seguem a documentação oficial da Microsoft (outubro de 2026), mas os números exatos de versão e os textos dos instaladores podem variar um pouco no seu computador. Já o programa C# do fim da aula é real e foi rodado no Linux e no editor do guia.

A ideia: o mesmo motor, carros diferentes

Uma montadora usa o mesmo motor em vários modelos de carro. O motor é igual; o que muda é a carroceria, o lugar do painel e onde fica o tanque. O .NET é assim: o compilador, o Runtime e a biblioteca são os mesmos nos três sistemas, e um programa feito num roda nos outros. O que muda é o "encaixe" em cada sistema:

	Linux (Ubuntu)	Windows	macOS
Como instalar	`sudo apt install dotnet-sdk-10.0`	`winget` ou instalador `.exe`	Instalador `.pkg`
Onde fica	`/usr/lib/dotnet`	`C:\Program Files\dotnet`	`/usr/local/share/dotnet`
Terminal	Terminal (bash)	Terminal do Windows (PowerShell)	Terminal (zsh)
Separador de pastas	`/`	`\`	`/`
Comando para rodar	`dotnet run ola.cs`, igual nos três

Antes de tudo: o terminal

O guia usa muito o terminal: a janela de texto onde você digita comandos. Não tenha medo dele; você vai usar poucos comandos, e eles são iguais nos três sistemas.

Windows 10 e 11: clique com o botão direito no botão Iniciar e escolha Terminal (no Windows 10, Windows PowerShell). Abre uma janela com algo como PS C:\Users\ana>: o PS é de PowerShell e C:\Users\ana é a sua pasta pessoal.
macOS: aperte Cmd+Espaço, digite Terminal e tecle Enter. Abre uma janela com algo como ana@MacBook ~ %.

Antes de instalar, pergunte se o .NET já está aí (ilustrativo):

dotnet --version

Se aparecer um número começando com 10., você já tem o .NET 10: pule para Testando. Se aparecer uma mensagem de "não reconhecido" ou "not found", siga em frente.

Windows

O .NET 10 tem suporte oficial no Windows 11, em processadores Intel/AMD (x64) e ARM (Arm64). No Windows 10, o suporte oficial ficou só para as edições Enterprise e LTSC, porque o Windows 10 comum saiu de suporte em outubro de 2025: o .NET pode até funcionar nele, mas sem garantia. Escolha uma das três formas abaixo.

Forma 1: `winget` (a mais rápida)

O winget é o gerenciador de pacotes do Windows, o "apt do Windows". Ele já vem no Windows 11 e nas versões atualizadas do Windows 10. No Terminal, digite:

winget install Microsoft.DotNet.SDK.10

winget: O gerenciador de pacotes do Windows (Windows Package Manager).
install: A ação: instalar.
Microsoft.DotNet.SDK.10: O nome do pacote: o SDK do .NET 10, da Microsoft. Para o Runtime sozinho, seria Microsoft.DotNet.Runtime.10; para o .NET 8, Microsoft.DotNet.SDK.8.

O winget baixa o instalador oficial e o roda. O Windows pergunta se você permite que o programa faça alterações (o "Controle de Conta de Usuário"): clique em Sim. No fim, aparece Instalado com êxito. Para ver as versões que o winget conhece:

winget search Microsoft.DotNet.SDK

Forma 2: o instalador do site

Abra https://dotnet.microsoft.com/download no navegador. Desconfie de outros sites: o .NET é gratuito e só deve ser baixado da Microsoft.
Na parte do .NET 10.0, clique em Download .NET SDK x64. (Se o seu computador tem processador ARM, como alguns notebooks com Snapdragon, escolha a versão Arm64 na página "Todas as versões do .NET 10".)
Rode o arquivo baixado, com um nome como dotnet-sdk-10.0.402-win-x64.exe.
Clique em Instalar, aceite a pergunta do Windows e espere. No fim, o instalador mostra uma lista do que foi instalado (o SDK, o Runtime, o ASP.NET Core Runtime e o Windows Desktop Runtime) e links para a documentação.
Feche o Terminal e abra de novo. Só os terminais abertos depois da instalação enxergam o comando dotnet.

Forma 3: junto com o Visual Studio 2026

O Visual Studio é o ambiente de programação completo da Microsoft, só para Windows (aula Editores e IDEs). O .NET 10 exige o Visual Studio 2026 (versão 18.0 ou mais nova); a edição Community é gratuita para estudantes, pessoas físicas e projetos de código aberto. No instalador do Visual Studio, marque a carga de trabalho Desenvolvimento para desktop com .NET (ou ASP.NET e desenvolvimento Web): o .NET 10 SDK vem junto.

O download do Visual Studio é bem maior (alguns gigabytes). Se você vai usar o VS Code ou outro editor, as formas 1 e 2 bastam.

Conferindo no Windows

PS C:\Users\ana> dotnet --version
10.0.402
PS C:\Users\ana> dotnet --list-sdks
10.0.402 [C:\Program Files\dotnet\sdk]

O número exato depende do mês em que você instalou: o site da Microsoft tem sempre a correção mais nova (em outubro de 2026, a 10.0.402). Qualquer 10.0.xxx serve para o guia. Repare que o .NET mora em C:\Program Files\dotnet, com a barra invertida \ do Windows.

O primeiro programa no Windows

Crie uma pasta, um arquivo e rode, como no Linux. O mkdir e o cd funcionam igual no PowerShell. Para criar o arquivo, use o Bloco de Notas (notepad ola.cs abre o Bloco de Notas já com esse nome) ou o seu editor:

PS C:\Users\ana> mkdir cs
PS C:\Users\ana> cd cs
PS C:\Users\ana\cs> notepad ola.cs
PS C:\Users\ana\cs> dotnet run ola.cs
Olá, mundo!

Na primeira vez, antes do Olá, mundo!, aparece a mensagem de boas-vindas do .NET (a mesma da aula Instalar no Linux), com um parágrafo a mais sobre telemetria: o .NET da Microsoft manda dados anônimos de uso das ferramentas. Para desligar, crie a variável de ambiente DOTNET_CLI_TELEMETRY_OPTOUT com o valor 1 (no PowerShell: [Environment]::SetEnvironmentVariable("DOTNET_CLI_TELEMETRY_OPTOUT", "1", "User"), e abra um Terminal novo).

Cuidado com o Bloco de Notas

Na hora de salvar, confira se o nome ficou ola.cs, e não ola.cs.txt. O Windows esconde as extensões por padrão; no Explorador de Arquivos, ative Exibir › Mostrar › Extensões de nomes de arquivos para enxergá-las.

macOS

O .NET 10 funciona no macOS 14 (Sonoma), 15 (Sequoia) e 26 (Tahoe). A primeira coisa é saber qual processador o seu Mac tem: no menu Apple (a maçã), clique em Sobre Este Mac. Se aparecer Chip Apple M1, M2, M3, M4…, o seu Mac é Arm64. Se aparecer Processador Intel, é x64.

Forma 1: o instalador `.pkg`

Abra https://dotnet.microsoft.com/download.
Na parte do .NET 10.0, baixe o SDK para macOS na arquitetura certa: Arm64 para os chips Apple, x64 para Intel. O arquivo tem um nome como dotnet-sdk-10.0.402-osx-arm64.pkg.
Abra o arquivo e siga o instalador: Continuar, Instalar, digite a senha do Mac.
Feche o Terminal e abra de novo.

O .NET vai para /usr/local/share/dotnet, e o instalador cria o arquivo /etc/paths.d/dotnet, que ensina o Terminal a achar o comando dotnet.

Forma 2: Homebrew ou o script

Quem usa o Homebrew (um gerenciador de pacotes para Mac, mantido pela comunidade, não pela Microsoft) pode instalar com brew install --cask dotnet-sdk. E o script dotnet-install.sh da aula Instalar no Linux também funciona no Mac, instalando na sua pasta pessoal, sem senha de administrador. Para quem está começando, o .pkg é o mais simples.

Conferindo no macOS

ana@MacBook ~ % dotnet --version
10.0.402
ana@MacBook ~ % dotnet --info | grep -E "OS Platform|RID|Architecture"
 OS Platform: Darwin
 RID:         osx-arm64
  Architecture: arm64

O Darwin é o nome do núcleo do macOS, e o RID osx-arm64 quer dizer "macOS em processador ARM". Se o seu Mac tem chip Apple e aparece x64, você instalou a versão errada (veja Quando dá errado). O primeiro programa é igual ao do Linux: mkdir cs, cd cs, crie o ola.cs e rode dotnet run ola.cs.

Testando: o mesmo programa nos três sistemas

Este programa pergunta ao .NET em que sistema ele está rodando e mostra a pasta pessoal e o separador de pastas. Os if e else if ("se… senão, se…") são da aula if e else; por enquanto, leia como "se for Windows, escreva isto; senão, se for macOS…".

if (OperatingSystem.IsWindows()) Console.WriteLine("Estou no Windows");
else if (OperatingSystem.IsMacOS()) Console.WriteLine("Estou no macOS");
else if (OperatingSystem.IsLinux()) Console.WriteLine("Estou no Linux");
else if (OperatingSystem.IsBrowser()) Console.WriteLine("Estou dentro de um navegador");

Console.WriteLine($"Pasta pessoal: {Environment.GetFolderPath(Environment.SpecialFolder.UserProfile)}");
Console.WriteLine($"Separador de pastas: {Path.DirectorySeparatorChar}");

No Linux da Ana (saída real):

$ dotnet run sistema.cs
Estou no Linux
Pasta pessoal: /home/ana
Separador de pastas: /

No Windows, o mesmo arquivo, sem mudar nada, mostraria Estou no Windows, Pasta pessoal: C:\Users\ana e Separador de pastas: \ (ilustrativo). É o mesmo programa; quem se adapta é o .NET. E no editor do guia? Rode e veja:

Experimente: rode. O editor responde Estou dentro de um navegador: aqui, o .NET roda em WebAssembly, dentro da página, e não direto no seu Windows, Mac ou Linux. A pasta pessoal que ele mostra é a de um computador de mentirinha, montado para parecer o da Ana.

if (OperatingSystem.IsWindows()) Console.WriteLine("Estou no Windows");
else if (OperatingSystem.IsMacOS()) Console.WriteLine("Estou no macOS");
else if (OperatingSystem.IsLinux()) Console.WriteLine("Estou no Linux");
else if (OperatingSystem.IsBrowser()) Console.WriteLine("Estou dentro de um navegador");

Console.WriteLine($"Pasta pessoal: {Environment.GetFolderPath(Environment.SpecialFolder.UserProfile)}");
Console.WriteLine($"Separador de pastas: {Path.DirectorySeparatorChar}");

O que muda entre os sistemas	Linux e macOS	Windows
Separador de pastas	`/home/ana/cs/ola.cs`	`C:\Users\ana\cs\ola.cs`
O "lançador" que o build cria	`ola`	`ola.exe`
Maiúsculas em nomes de arquivo	`Ola.cs` e `ola.cs` são dois arquivos (no Linux; no macOS, normalmente o mesmo)	O mesmo arquivo
Fim de linha nos arquivos de texto	`\n`	`\r\n` (o .NET lê os dois)
O código C#	Igual. Para montar caminhos sem se preocupar com a barra, use `Path.Combine` (aula Pastas e Caminhos).

Quando dá errado

As telas abaixo são ilustrativas, no formato que o Windows e o macOS usam.

Windows: O termo 'dotnet' não é reconhecido

PS C:\Users\ana> dotnet --version
dotnet : O termo 'dotnet' não é reconhecido como nome de cmdlet, função, arquivo de script ou programa operável.

O que aconteceu: o PowerShell não achou nenhum programa chamado dotnet. Quase sempre, o Terminal foi aberto antes da instalação e ainda não sabe que o .NET existe. Ou a instalação não terminou.

Como consertar: feche todas as janelas do Terminal e abra uma nova. Se continuar, rode o instalador de novo, ou confira se existe a pasta C:\Program Files\dotnet.

macOS: zsh: command not found: dotnet

ana@MacBook ~ % dotnet --version
zsh: command not found: dotnet

O que aconteceu: o mesmo do Windows: o Terminal foi aberto antes da instalação, ou o .NET foi instalado pelo script numa pasta que o Terminal não conhece.

Como consertar: feche o Terminal (Cmd+Q) e abra de novo. Se instalou pelo script, acrescente as linhas export DOTNET_ROOT=$HOME/.dotnet e export PATH=$PATH:$DOTNET_ROOT ao arquivo ~/.zshrc.

Mac com chip Apple e .NET x64

O que aconteceu: foi baixado o instalador x64 num Mac com chip M. Ele até funciona (pelo tradutor Rosetta 2 da Apple), mas fica numa pasta separada (/usr/local/share/dotnet/x64), roda mais devagar e confunde editores e ferramentas.

Como consertar: desinstale a versão x64 e instale a Arm64. Confira com dotnet --info: a linha Architecture tem de dizer arm64.

Instalou o Runtime em vez do SDK

O que aconteceu: na página de download, há vários botões: SDK, ".NET Runtime", "ASP.NET Core Runtime", ".NET Desktop Runtime". Quem baixa um Runtime consegue rodar programas prontos, mas o dotnet run responde No .NET SDKs were found. (aula .NET: SDK, Runtime e CLR).

Como consertar: baixe e instale o SDK, que já traz os Runtimes.

Windows: ola.cs.txt

O que aconteceu: o Bloco de Notas salvou o arquivo como ola.cs.txt, e o Windows escondeu o .txt. O dotnet run ola.cs não acha o arquivo e responde que não encontrou um projeto para executar (a mesma mensagem da aula Rodar com dotnet run).

Como consertar: mostre as extensões no Explorador de Arquivos e renomeie o arquivo para ola.cs. No Bloco de Notas, escolha Todos os arquivos no tipo, na hora de salvar.

Referência

Sistema	Instalar o .NET 10 SDK	Onde fica
Windows (winget)	`winget install Microsoft.DotNet.SDK.10`	`C:\Program Files\dotnet`
Windows (instalador)	`dotnet-sdk-10.0.xxx-win-x64.exe` do site `dotnet.microsoft.com`	`C:\Program Files\dotnet`
Windows (IDE)	Visual Studio 2026, com a carga de trabalho de .NET	`C:\Program Files\dotnet`
macOS (chip Apple)	`dotnet-sdk-10.0.xxx-osx-arm64.pkg`	`/usr/local/share/dotnet`
macOS (Intel)	`dotnet-sdk-10.0.xxx-osx-x64.pkg`	`/usr/local/share/dotnet`
Linux	Aula Instalar no Linux	`/usr/lib/dotnet` (Ubuntu)

Comando (igual nos três sistemas)	Para quê
`dotnet --version`	A versão do SDK
`dotnet --info`	Tudo: SDKs, Runtimes, sistema, arquitetura
`dotnet --list-sdks`	Os SDKs instalados
`dotnet run ola.cs`	Compilar e rodar o arquivo

Exercícios

1. O winget

Complete o comando que instala o .NET 10 SDK no Windows:

winget install Microsoft.DotNet.

2. A arquitetura do Mac

Um Mac com chip Apple M3 precisa do instalador de qual arquitetura?

3. A pasta do Windows

Complete a pasta onde o .NET fica no Windows:

C:\Program Files\

4. Você instalou o .NET e, no mesmo Terminal que já estava aberto, o dotnet "não é reconhecido". O que fazer primeiro?

Formatar o computador. Instalar o .NET Framework. Fechar o Terminal e abrir um novo. Trocar de editor.

5. Um programa feito pela Ana no Ubuntu precisa de mudanças no código para rodar no Windows?

Sim, é preciso reescrever tudo. Não: o .NET é o mesmo e o código C# roda igual (cuidado só com caminhos de pastas escritos à mão). Só se ele usar Console.WriteLine. Sim, o C# do Windows é outra linguagem.

6. Qual Visual Studio é preciso para o .NET 10?

O Visual Studio 2026 (versão 18.0 ou mais nova). Qualquer um, até o 2010. O Visual Studio for Mac. Nenhum funciona com o .NET 10.

Missão final: o seu sistema

Missão: a Bia, amiga da Ana, usa um Mac e instalou o .NET pelo instalador .pkg. Mude o cartão para ela: troque Linux por macOS e apt por pkg, e rode.

Console.WriteLine("Sistema: Linux");
Console.WriteLine("Instalei com: apt");
Console.WriteLine("Comando para rodar: dotnet run ola.cs");

Console.WriteLine("Sistema: macOS");
Console.WriteLine("Instalei com: pkg");
Console.WriteLine("Comando para rodar: dotnet run ola.cs");

Repare que a terceira linha não muda: o comando para rodar é o mesmo nos três sistemas.

Resumo

O .NET é o mesmo nos três sistemas; só muda o jeito de instalar e a pasta onde ele fica.
Windows: winget install Microsoft.DotNet.SDK.10, o instalador .exe de dotnet.microsoft.com/download ou o Visual Studio 2026. Fica em C:\Program Files\dotnet.
macOS: o instalador .pkg, na arquitetura certa: Arm64 para chips Apple, x64 para Intel. Fica em /usr/local/share/dotnet.
Instale o SDK, não só um Runtime. Depois de instalar, abra um Terminal novo.
Confira com dotnet --version e dotnet --info; o primeiro programa roda com dotnet run ola.cs, igual no Linux.
Próximo passo: escolher onde escrever o código, em Editores e IDEs.