C# Instalar no Linux

As caixas Experimente do guia compilam e rodam C# no navegador, mas, para programar de verdade, você vai querer o .NET SDK no seu computador. No Linux, isso é fácil: no Ubuntu, ele está no repositório oficial, a um comando de distância. Nesta aula você instala o .NET 10 SDK no Ubuntu (e vê os comandos do Debian, do Fedora e do Arch), confere a instalação com dotnet --version e dotnet --info, vê a mensagem de boas-vindas do primeiro uso e roda o primeiro programa.

Esta aula é para quem usa Linux. No Windows ou no macOS, veja Instalar no Windows e macOS. As saídas de terminal foram produzidas na máquina da Ana, que usa Ubuntu 26.04 com o .NET já instalado. Por isso, no ponto em que se instala de verdade, a aula mostra a simulação que o próprio apt faz, e marca como ilustrativo o que não foi rodado.

A ideia: a loja de aplicativos do Linux

No celular, você não procura aplicativos em sites aleatórios: abre a loja, procura pelo nome e toca em "Instalar". A loja baixa o aplicativo, instala, e depois avisa quando há atualização. O Linux tem isso há muito mais tempo que os celulares: é o gerenciador de pacotes. Cada programa vem num pacote, e o gerenciador baixa os pacotes de um repositório oficial da sua distribuição, com tudo de que o programa precisa para funcionar (as dependências).

Para programar em C#, você precisa de um pacote só: o .NET SDK (aula .NET: SDK, Runtime e CLR). Ele traz o compilador de C#, o Runtime que roda os programas, a biblioteca de classes e o comando dotnet.

1. O .NET já está instalado?

Antes de instalar, pergunte. Abra o terminal (no Ubuntu: Ctrl+Alt+T) e digite:

$ dotnet --version
10.0.112                                        « está instalado: SDK 10.0.112

Se apareceu um número começando com 10., você já tem o .NET 10 e pode pular para a seção 4. Se o número começa com 8. ou 9., você tem uma versão mais antiga, que sai de suporte em novembro de 2026 (aula Versões): instale também o 10, que os dois convivem. Se o .NET não estiver instalado, a resposta é esta:

$ dotnet --version
bash: dotnet: comando não encontrado            « o terminal não achou nenhum programa chamado dotnet
$ echo $?
127                                             « 127: "comando não encontrado"

(No Ubuntu de computador, logo abaixo pode aparecer uma sugestão de qual pacote tem o comando.) Nesse caso, siga a seção da sua distribuição.

2. Ubuntu: dotnet-sdk-10.0

Desde o Ubuntu 22.04, o .NET está no repositório oficial do Ubuntu: a Canonical (a empresa do Ubuntu) compila o .NET a partir do código-fonte e o mantém atualizado, como qualquer outro programa do sistema. No Ubuntu 26.04, o pacote se chama dotnet-sdk-10.0. São dois comandos: o primeiro atualiza a lista de pacotes (o "catálogo da loja"); o segundo instala:

sudo apt update
sudo apt install dotnet-sdk-10.0

sudo

"Faça como administrador" (superuser do). Instalar programas mexe no sistema todo, então é preciso permissão de administrador. O sudo pede a sua senha, que não aparece enquanto você digita (nem bolinhas): é normal, digite e tecle Enter.

apt

O gerenciador de pacotes do Ubuntu e do Debian.

update

Baixa a lista mais nova de pacotes e versões. Não instala nada.

install

A ação: instalar.

dotnet-sdk-10.0

O nome do pacote: o SDK do .NET 10. O -10.0 no nome deixa várias versões conviverem (dotnet-sdk-8.0, dotnet-sdk-10.0…).

O que vem junto

O apt-cache depends mostra de que o pacote depende:

$ apt-cache depends dotnet-sdk-10.0
dotnet-sdk-10.0
  Depende: aspnetcore-runtime-10.0                « o Runtime para sites (ASP.NET Core)
  Depende: aspnetcore-targeting-pack-10.0
  Depende: dotnet-apphost-pack-10.0               « o "lançador" dos programas
  Depende: dotnet-runtime-10.0                    « o Runtime: CLR, JIT, biblioteca
  Depende: dotnet-targeting-pack-10.0             « as "plantas" da biblioteca para o compilador
  Depende: dotnet-templates-10.0                  « os modelos do dotnet new
  Depende: ca-certificates
  Depende: libc6
  Depende: libgcc-s1
  Depende: libstdc++6
  Quebra: <dotnet-sdk-6.0>                       « não convive com o pacote antigo do .NET 6
  Recomenda: dotnet-sdk-aot-10.0                  « recomendado: entra junto por padrão
  Sugere: dotnet-sdk-dbg-10.0                     « sugerido: NÃO entra sozinho

Repare que o SDK depende do dotnet-runtime-10.0: é por isso que, instalando o SDK, você ganha o Runtime de graça. As quatro últimas dependências (libc6 e companhia) são bibliotecas básicas do sistema que todo Ubuntu já tem.

A simulação

Dá para ver o que aconteceria, sem instalar nada, com a opção -s (simulate, "simular"). A simulação nem precisa de sudo. Como a Ana já tem o .NET, a resposta direta é curta:

$ apt install -s dotnet-sdk-10.0
NOTA: Esta é apenas uma simulação!
      apt precisa de privilégios de root para execução real.
      Lembre-se também de que a trava está desativada e,
      portanto, não dependa da relevância para a situação real atual!

dotnet-sdk-10.0 já é a versão mais nova (10.0.112-0ubuntu1~26.04.1).   « nada a fazer
Resumo:
  Atualizando: 0, Instalando: 0, Removendo: 0, Não atualizando: 0

Para ver a simulação de um computador sem o .NET, a Ana fez uma cópia da lista de pacotes instalados (o arquivo /var/lib/dpkg/status) sem as linhas do .NET, guardou em ~/.cache/sim/status e pediu ao apt para usar essa cópia (a opção -o Dir::State::status=…). O resto é a resposta real do apt:

$ apt install -s -o Dir::State::status=$HOME/.cache/sim/status dotnet-sdk-10.0
NOTA: Esta é apenas uma simulação!
      apt precisa de privilégios de root para execução real.
      Lembre-se também de que a trava está desativada e,
      portanto, não dependa da relevância para a situação real atual!

Instalando:                                       « o que você pediu
  dotnet-sdk-10.0

Instalando dependências:                          « o que vem junto, automaticamente
  aspnetcore-runtime-10.0         dotnet-runtime-10.0
  aspnetcore-targeting-pack-10.0  dotnet-sdk-aot-10.0
  dotnet-apphost-pack-10.0        dotnet-targeting-pack-10.0
  dotnet-host-10.0                dotnet-templates-10.0
  dotnet-hostfxr-10.0

Pacotes sugeridos:                                « opcionais: NÃO serão instalados
  aspnetcore-runtime-dbg-10.0  dotnet-runtime-dbg-10.0  dotnet-sdk-dbg-10.0

Resumo:
  Atualizando: 0, Instalando: 10, Removendo: 0, Não atualizando: 0
Inst dotnet-host-10.0 (10.0.12-0ubuntu1~26.04.1 Ubuntu:26.04/resolute-updates, Ubuntu:26.04/resolute-security [amd64])
Inst dotnet-hostfxr-10.0 (10.0.12-0ubuntu1~26.04.1 Ubuntu:26.04/resolute-updates, Ubuntu:26.04/resolute-security [amd64])
Inst dotnet-runtime-10.0 (10.0.12-0ubuntu1~26.04.1 Ubuntu:26.04/resolute-updates, Ubuntu:26.04/resolute-security [amd64])
Inst aspnetcore-runtime-10.0 (10.0.12-0ubuntu1~26.04.1 Ubuntu:26.04/resolute-updates, Ubuntu:26.04/resolute-security [amd64])
Inst aspnetcore-targeting-pack-10.0 (10.0.12-0ubuntu1~26.04.1 Ubuntu:26.04/resolute-updates, Ubuntu:26.04/resolute-security [amd64])
Inst dotnet-apphost-pack-10.0 (10.0.12-0ubuntu1~26.04.1 Ubuntu:26.04/resolute-updates, Ubuntu:26.04/resolute-security [amd64])
Inst dotnet-targeting-pack-10.0 (10.0.12-0ubuntu1~26.04.1 Ubuntu:26.04/resolute-updates, Ubuntu:26.04/resolute-security [amd64])
Inst dotnet-templates-10.0 (10.0.112-0ubuntu1~26.04.1 Ubuntu:26.04/resolute-updates, Ubuntu:26.04/resolute-security [amd64])
Inst dotnet-sdk-10.0 (10.0.112-0ubuntu1~26.04.1 Ubuntu:26.04/resolute-updates, Ubuntu:26.04/resolute-security [amd64])
Inst dotnet-sdk-aot-10.0 (10.0.112-0ubuntu1~26.04.1 Ubuntu:26.04/resolute-updates, Ubuntu:26.04/resolute-security [amd64])
Conf dotnet-host-10.0 (10.0.12-0ubuntu1~26.04.1 Ubuntu:26.04/resolute-updates, Ubuntu:26.04/resolute-security [amd64])
…                                                 « mais 9 linhas Conf, uma por pacote

Você pediu um pacote, e o apt traria dez. As linhas Inst ("instalar") mostram a ordem: primeiro o dotnet-host-10.0 (o comando dotnet) e o dotnet-hostfxr-10.0 (a peça que escolhe qual versão do .NET usar), depois o Runtime e, no fim, o SDK. As linhas Conf ("configurar") vêm depois de tudo desempacotado. Esse é o trabalho do gerenciador: resolver as dependências por você. Somando o tamanho dos dez pacotes, são cerca de 163 MB para baixar e uns 620 MB de espaço em disco.

Numa instalação de verdade, com sudo e sem o -s, o Resumo mostra também o tamanho do download e o espaço necessário, e vêm a pergunta Continuar? [S/n] (tecle Enter: o S maiúsculo é a resposta padrão), as linhas Obter: do download e as linhas Desempacotando … e Configurando … de cada pacote (ilustrativo: a Ana já tinha o .NET). Em uma conexão comum, leva um ou dois minutos.

Qual versão vou receber?

O apt-cache policy mostra a versão instalada e as disponíveis:

$ apt-cache policy dotnet-sdk-10.0
dotnet-sdk-10.0:
  Instalado: 10.0.112-0ubuntu1~26.04.1             « a instalada
  Candidato: 10.0.112-0ubuntu1~26.04.1             « a que o apt instalaria (a mesma: está em dia)
  Tabela de versão:
 *** 10.0.112-0ubuntu1~26.04.1 500
        500 http://archive.ubuntu.com/ubuntu resolute-updates/main amd64 Packages
        500 http://security.ubuntu.com/ubuntu resolute-security/main amd64 Packages
        100 /var/lib/dpkg/status
     10.0.105-0ubuntu1 500                         « a que veio no lançamento do Ubuntu 26.04
        500 http://archive.ubuntu.com/ubuntu resolute/main amd64 Packages

Como ler 10.0.112-0ubuntu1~26.04.1: 10.0.112 é a versão do SDK, e o resto é a revisão do pacote feita pelo Ubuntu. O resolute é o apelido do Ubuntu 26.04. Repare nas duas versões: o Ubuntu 26.04 saiu com o SDK 10.0.105, e as correções mensais chegaram pelo resolute-updates e pelo resolute-security até o 10.0.112. É por isso que vale rodar o sudo apt upgrade de vez em quando.

Ubuntu 24.04 e 22.04

Nas versões mais antigas do Ubuntu, o .NET 10 também existe, às vezes num repositório extra. Segundo a documentação oficial da Microsoft (ilustrativo, não rodado na máquina da Ana):

O repositório extra se chama Ubuntu .NET backports e é mantido pela equipe do .NET no Ubuntu. Para acrescentá-lo (ilustrativo):

sudo add-apt-repository ppa:dotnet/backports
sudo apt update
sudo apt install dotnet-sdk-10.0

3. Debian, Fedora, Arch e outras formas

Nas outras distribuições, os comandos seguem a documentação oficial de cada uma. Eles não foram executados na máquina da Ana (que é Ubuntu), por isso a tabela é ilustrativa:

Sem administrador: o script dotnet-install.sh

A Microsoft oferece um script que instala o .NET na sua pasta pessoal, sem sudo. Ele serve para computadores em que você não é administrador ou para ter uma versão que a sua distribuição ainda não tem (ilustrativo):

wget https://dot.net/v1/dotnet-install.sh -O dotnet-install.sh
chmod +x dotnet-install.sh
./dotnet-install.sh --channel 10.0

O .NET vai para ~/.dotnet, e você precisa avisar o terminal onde ele está, acrescentando ao fim do arquivo ~/.bashrc as linhas export DOTNET_ROOT=$HOME/.dotnet e export PATH=$PATH:$DOTNET_ROOT. A desvantagem: o apt upgrade não atualiza essa cópia; você precisa rodar o script de novo a cada correção.

Qual escolher?

4. Conferindo a instalação

Depois de instalar, confira. O primeiro comando mostra só a versão do SDK:

$ dotnet --version
10.0.112

O segundo mostra tudo o que o .NET sabe sobre si mesmo e sobre o computador:

$ dotnet --info
.NET SDK:
 Version:           10.0.112                         « o SDK
 Commit:            95017c711e
 Workload version:  10.0.100-manifests.63b36e85
 MSBuild version:   18.0.11+95017c711

Ambiente de runtime:
 OS Name:     ubuntu
 OS Version:  26.04
 OS Platform: Linux                                  « o sistema
 RID:         ubuntu.26.04-x64
 Base Path:   /usr/lib/dotnet/sdk/10.0.112/

Cargas de trabalho do .NET instaladas:
Não há cargas de trabalho instaladas para exibir.
Configurado para usar workload sets ao instalar novos manifestos.
Nenhum conjunto de cargas de trabalho está instalado. Execute "dotnet workload restore" para instalar um conjunto de cargas de trabalho.

Host:
  Version:      10.0.12                              « o comando dotnet e o Runtime
  Architecture: x64
  Commit:       95017c711e

.NET SDKs installed:
  10.0.112 [/usr/lib/dotnet/sdk]

.NET runtimes installed:
  Microsoft.AspNetCore.App 10.0.12 [/usr/lib/dotnet/shared/Microsoft.AspNetCore.App]
  Microsoft.NETCore.App 10.0.12 [/usr/lib/dotnet/shared/Microsoft.NETCore.App]

Other architectures found:
  None

Environment variables:
  Not set

global.json file:
  Not found

Learn more:
  https://aka.ms/dotnet/info

Download .NET:
  https://aka.ms/dotnet/download

.NET SDK

A versão do SDK (10.0.112) e do MSBuild, o "mestre de obras" do build.

Ambiente de runtime

O sistema (ubuntu 26.04, Linux) e o RID (runtime identifier), o "nome técnico" da plataforma: ubuntu.26.04-x64 = Ubuntu 26.04 em processador x64.

Cargas de trabalho

Pacotes opcionais para celular, navegador etc. (workloads). O guia não precisa de nenhuma; pode ignorar essas linhas.

Host

O comando dotnet em si (o "anfitrião"), versão 10.0.12.

SDKs installed e runtimes installed

O mesmo que dotnet --list-sdks e dotnet --list-runtimes (aula .NET: SDK, Runtime e CLR).

global.json file: Not found

Um arquivo opcional que fixa a versão do SDK de uma pasta. Sem ele, vale o SDK mais novo instalado.

Repare que a saída mistura português e inglês: as partes do SDK estão traduzidas, e as do dotnet básico (o host), não. É assim mesmo. Para ver onde o comando está:

$ which dotnet                                    « onde está o comando
/usr/bin/dotnet
$ readlink -f $(which dotnet)                     « para onde aponta o atalho
/usr/lib/dotnet/dotnet

O /usr/bin/dotnet é um atalho (um link simbólico) para o dotnet de verdade, que mora em /usr/lib/dotnet, junto com o SDK e os Runtimes.

5. O primeiro uso: a mensagem de boas-vindas

O --version e o --info só respondem. Mas, na primeira vez que você usa um comando de verdade do SDK, como o dotnet run, ele se apresenta. Crie uma pasta para os seus programas, entre nela e crie o arquivo ola.cs com um editor de texto (o editor de textos do seu sistema, o nano ola.cs no terminal, ou um editor de programação, aula Editores e IDEs), com uma linha só:

$ mkdir cs                                        « cria a pasta cs na sua pasta pessoal
$ cd cs                                           « entra nela

Console.WriteLine("Olá, mundo!");

Agora rode com dotnet run ola.cs. Na primeira vez, aparece isto:

$ dotnet run ola.cs

Bem-vindo(a) ao .NET 10.0.
---------------------
Versão do SDK: 10.0.112

----------------
Instalou um certificado de desenvolvimento ASP.NET Core HTTPS.
Para confiar no certificado, execute 'dotnet dev-certs https --trust'
Saiba mais HTTPS: https://aka.ms/dotnet-https

----------------
Escreva seu primeiro aplicativo: https://aka.ms/dotnet-hello-world
Descubra o que há de novo: https://aka.ms/dotnet-whats-new
Explorar a documentação: https://aka.ms/dotnet-docs
Relate problemas e encontre a fonte no GitHub: https://github.com/dotnet/core
Use 'dotnet --help' para ver os comandos disponíveis ou visite: https://aka.ms/dotnet-cli
--------------------------------------------------------------------------------------
Olá, mundo!                                       « e, no fim, o seu programa

Bem-vindo(a) ao .NET 10.0

A apresentação, com a versão do SDK.

certificado de desenvolvimento ASP.NET Core HTTPS

O SDK criou um certificado para testar sites com https:// no seu computador. Só interessa para quem faz sites com ASP.NET Core; para o guia, pode ignorar.

Os endereços aka.ms

Atalhos para a documentação oficial: o primeiro programa, as novidades, a referência do comando dotnet.

Olá, mundo!

Depois da apresentação, o programa rodou normalmente.

A mensagem aparece uma vez só. O .NET anota que já se apresentou criando uns arquivinhos na pasta escondida ~/.dotnet, e da segunda vez em diante vai direto ao programa:

$ ls -a ~/.dotnet
.
..
10.0.112.aspNetCertificateSentinel                « "já criei o certificado"
10.0.112.dotnetFirstUseSentinel                   « "já me apresentei"
10.0.112.toolpath.sentinel
corefx
$ dotnet run ola.cs
Olá, mundo!                                       « da segunda vez, só o programa

Sentinel quer dizer "sentinela": arquivos vazios que só servem para marcar que algo já foi feito. Se você apagar esses arquivos, a mensagem aparece de novo no próximo comando.

6. O teste final: o C# 14

O Olá, mundo! provou que o SDK funciona. Falta conferir a versão da linguagem. Este programa usa uma novidade do C# 14, a atribuição com ?. ("se o cliente existir, mude o nome dele"). Não precisa entender o código agora: a aula Operadores ??, ?. e ??= explica.

Cliente? cliente = new Cliente();
cliente?.Nome = "Ana";
Console.WriteLine($"C# 14 funcionando! Cliente: {cliente?.Nome}");

class Cliente
{
    public string Nome { get; set; } = "";
}

$ dotnet run teste14.cs
C# 14 funcionando! Cliente: Ana                   « tudo certo

Se apareceu essa linha, o seu computador está pronto para o guia inteiro. Com um SDK mais antigo (do .NET 9, por exemplo), o mesmo arquivo dá o erro CS9260: O recurso "atribuição condicional nula" não está disponível no C# 13.0 (aula Versões). O mesmo programa roda aqui no editor, que também usa o C# 14:

Cliente? cliente = new Cliente();
cliente?.Nome = "Ana";
Console.WriteLine($"C# 14 funcionando! Cliente: {cliente?.Nome}");

class Cliente
{
    public string Nome { get; set; } = "";
}

Atualizando

O gerenciador de pacotes também cuida das atualizações. De tempos em tempos, rode (ilustrativo):

sudo apt update
sudo apt upgrade

O upgrade atualiza todos os programas instalados, incluindo o .NET, para a última correção (de 10.0.112 para 10.0.113, por exemplo). Ele não troca o .NET 10 pelo 11: versões novas do .NET chegam como pacotes novos, com outro número no nome (dotnet-sdk-11.0), e as duas convivem.

Quando dá errado

$ dotnet --version
bash: dotnet: comando não encontrado

$ apt install dotnet-sdk-dbg-10.0
Erro: Não foi possível abrir arquivo de trava /var/lib/dpkg/lock-frontend - open (13: Permissão negada)
Erro: Não é possível adquirir a trava da interface do dpkg (/var/lib/dpkg/lock-frontend), você é root?
$ echo $?
100

Referência

Exercícios

Missão final: o cartão da instalação

Para comemorar, um programa que mostra o que a Ana instalou. Faça a missão aqui no editor e, depois, repita no seu terminal com dotnet run.

Console.WriteLine("Instalado no notebook da Ana:");
Console.WriteLine("SDK 10.0.112");
Console.WriteLine("Runtime 10.0.12");

Console.WriteLine("Instalado no notebook da Ana:");
Console.WriteLine("SDK 10.0.112");
Console.WriteLine("Runtime 10.0.12");
Console.WriteLine("C# 14");

Resumo

• O Linux instala programas pelo gerenciador de pacotes: apt (Ubuntu/Debian), dnf (Fedora), pacman (Arch), snap.
• Antes de instalar, pergunte: dotnet --version. Para o guia, o SDK tem de começar com 10..
• No Ubuntu 26.04 e 24.04: sudo apt update e sudo apt install dotnet-sdk-10.0. O apt traz dez pacotes, com o Runtime junto (cerca de 163 MB de download).
• Debian usa o repositório da Microsoft; Fedora, dnf install dotnet-sdk-10.0; Arch, pacman -S dotnet-sdk; sem administrador, o dotnet-install.sh. Não misture duas fontes.
• Confira com dotnet --version e dotnet --info. No primeiro comando de verdade, aparece a mensagem Bem-vindo(a) ao .NET 10.0., uma vez só.
• O teste final: um programa com um recurso do C# 14 tem de rodar.
• Próximo passo: escolher onde escrever o código, em Editores e IDEs.