C# Pacotes NuGet

O .NET já vem com muita coisa: listas, arquivos, JSON, datas. Mas um dia a Ana vai querer escrever "1.234" por extenso, mostrar "há 3 dias", desenhar uma tabela colorida no terminal ou ler uma planilha. Alguém no mundo já escreveu esse código, testou e deixou de graça para todos. Esse código empacotado se chama pacote, e a loja onde ficam os pacotes do .NET se chama NuGet. Nesta aula você vai procurar, instalar, atualizar e remover pacotes, e entender o que o dotnet faz com eles.

Você vai aprender

O que é um pacote, o que é o nuget.org e como procurar com dotnet package search.
A instalar com dotnet package add e a ler a linha PackageReference que ele põe no .csproj.
Onde os pacotes ficam (~/.nuget/packages) e o que é "restaurar".
Versões: escolher, ver as desatualizadas (--outdated), as perigosas (--vulnerable) e as dependências das dependências.
A remover com dotnet package remove e a usar pacotes num arquivo solto com #:package .NET 10.
Os erros: pacote que não existe, versão que não existe (NU1102), o using esquecido (CS1061) e a falta de internet.

Todas as saídas desta aula são reais, feitas com o .NET 10 SDK (10.0.112) na máquina fictícia da Ana, conectada à internet, no projeto ~/projetos/Prazo. As versões dos pacotes são as do dia da gravação: na sua máquina, os números podem ser mais novos. O editor do guia não baixa pacotes: tudo o que usa NuGet roda no terminal.

A ideia: a loja de aplicativos do programador

No celular, você não escreve o aplicativo do banco: você o baixa da loja. A loja guarda milhões de aplicativos, cada um com nome, versão, autor e número de downloads. O NuGet é a loja de aplicativos do programador .NET, com uma diferença: o que você baixa não é um programa para usar, e sim código para o seu programa usar.

Na loja do celular	No .NET
A loja	`nuget.org`, o site oficial, com centenas de milhares de pacotes
Um aplicativo	Um pacote: um arquivo `.nupkg` com `.dll` prontas
Instalar	`dotnet package add Nome`
A lista de apps instalados	As linhas `<PackageReference>` do `.csproj`
Atualizar	Trocar a versão (seção 5)

"NuGet" se pronuncia "new get" ("novo pegar"). O nome serve para três coisas: o formato dos pacotes, o site nuget.org e a ferramenta que o dotnet usa por baixo para baixá-los.

1. Procurar um pacote

A Ana quer escrever números e tempos "como gente fala": "3 dias", "mil duzentos e trinta e quatro". O pacote mais conhecido para isso é o Humanizer ("humanizador"). Dá para procurar no site nuget.org ou no próprio terminal:

$ dotnet package search humanizer --take 5
****************************************
Source: nuget.org (https://api.nuget.org/v3/index.json)
| Package ID       | Latest Version | Owners           | Total Downloads |
| ---------------- | -------------- | ---------------- | --------------- |
| Humanizer        | 3.0.10         | dotnetfoundation | 164.607.656     |
|                  |                | , Humanizer      |                 |
| ---------------- | -------------- | ---------------- | --------------- |
| Humanizer.Core   | 3.0.10         | dotnetfoundation | 1.117.217.029   |
|                  |                | , Humanizer      |                 |
| ---------------- | -------------- | ---------------- | --------------- |
| Humanizer.Core.h | 3.0.10         | dotnetfoundation | 159.550.846     |
| e                |                | , Humanizer      |                 |
| ---------------- | -------------- | ---------------- | --------------- |
| Humanizer.Core.e | 3.0.10         | dotnetfoundation | 159.531.102     |
| l                |                | , Humanizer      |                 |
| ---------------- | -------------- | ---------------- | --------------- |
| Humanizer.Core.f | 3.0.10         | dotnetfoundation | 161.283.743     |
| r                |                | , Humanizer      |                 |
| ---------------- | -------------- | ---------------- | --------------- |

--take 5: "Pegue 5": só os 5 primeiros resultados (o padrão é 20).
Package ID: O nome do pacote, que você vai digitar no add. A tabela corta os nomes compridos em duas linhas: Humanizer.Core.h + e é o Humanizer.Core.he (hebraico), Humanizer.Core.el é o grego, Humanizer.Core.fr, o francês.
Latest Version: A versão mais nova.
Owners: Os donos: aqui, a .NET Foundation, a fundação que cuida de muitos projetos abertos do .NET.
Total Downloads: Quantas vezes foi baixado. O Humanizer.Core passa de 1 bilhão.

O Humanizer vem em pedaços: o Humanizer.Core (o código, com as regras do inglês), um pacote para cada idioma (Humanizer.Core.pt-BR é o português do Brasil) e o Humanizer, que traz o Core com todos os idiomas. A Ana só precisa do português, então ela vai instalar o Humanizer.Core.pt-BR.

Como escolher um pacote: no nuget.org, veja o número de downloads, a data da última versão (um pacote parado há 5 anos pode não funcionar bem no .NET 10), o dono e o link para o código-fonte. Desconfie de nomes parecidos com os de pacotes famosos: já houve pacotes falsos feitos para enganar quem erra uma letra.

2. Instalar: `dotnet package add`

Dentro da pasta do projeto (criado com dotnet new console -o Prazo):

$ dotnet package add Humanizer.Core.pt-BR
info : A validação da cadeia de certificados X.509 usará o pacote de certificados de fallback em '/usr/lib/dotnet/sdk/10.0.112/trustedroots/codesignctl.pem'.
info : A validação da cadeia de certificados X.509 usará o pacote de certificados de fallback em '/usr/lib/dotnet/sdk/10.0.112/trustedroots/timestampctl.pem'.
info : Adicionando PackageReference do pacote 'Humanizer.Core.pt-BR' ao projeto '/home/ana/projetos/Prazo/Prazo.csproj'.
info :   GET https://api.nuget.org/v3/registration5-gz-semver2/humanizer.core.pt-br/index.json
info :   OK https://api.nuget.org/v3/registration5-gz-semver2/humanizer.core.pt-br/index.json 267 ms
info : Restaurando pacotes para /home/ana/projetos/Prazo/Prazo.csproj...
«… mais 4 linhas de download …»
info : Instalado Humanizer.Core.pt-BR3.0.10 de https://api.nuget.org/v3/index.json para /home/ana/.nuget/packages/humanizer.core.pt-br/3.0.10 com hash de conteúdo «…»
info : Instalado Humanizer.Core3.0.10 de https://api.nuget.org/v3/index.json para /home/ana/.nuget/packages/humanizer.core/3.0.10 com hash de conteúdo «…»
«… 3 linhas de consulta à lista de vulnerabilidades …»
info : O pacote 'Humanizer.Core.pt-BR' é compatível com todas as estruturas especificadas no projeto '/home/ana/projetos/Prazo/Prazo.csproj'.
info : PackageReference do pacote 'Humanizer.Core.pt-BR' versão '3.0.10' adicionada ao arquivo '/home/ana/projetos/Prazo/Prazo.csproj'.
info : Gerando arquivo do MSBuild /home/ana/projetos/Prazo/obj/Prazo.csproj.nuget.g.targets.
info : Gravando o arquivo de ativos no disco. Caminho: /home/ana/projetos/Prazo/obj/project.assets.json
log  : /home/ana/projetos/Prazo/Prazo.csproj restaurado (em 420 ms).

É bastante coisa, mas dá para ler em ordem:

A validação da cadeia de certificados X.509…: Os pacotes do nuget.org são assinados digitalmente, e o dotnet confere a assinatura para saber que ninguém mexeu neles no caminho. Essas linhas só dizem qual lista de certificados ele usa para conferir. Pode ignorar.
Adicionando PackageReference…: Vai acrescentar o pacote ao .csproj.
GET … / OK … 267 ms: Perguntou ao nuget.org quais versões existem ("GET" = pedir; "OK" = recebeu, em 267 milissegundos).
Instalado Humanizer.Core.pt-BR3.0.10 … para /home/ana/.nuget/packages/…: Baixou o pacote e o guardou na pasta ~/.nuget/packages (seção 4). O "hash de conteúdo" é uma impressão digital do arquivo.
Instalado Humanizer.Core3.0.10: A Ana pediu um pacote e vieram dois: o pt-BR precisa do Core, e o NuGet baixou os dois sozinho. Isso é uma dependência.
é compatível com todas as estruturas: O pacote funciona com o net10.0 do projeto ("estrutura" é a tradução de framework).
versão '3.0.10' adicionada ao arquivo: Sem dizer a versão, o add escolhe a mais nova e a anota no .csproj.
restaurado (em 420 ms): "Restaurar" é deixar todos os pacotes do projeto baixados e prontos.

O que mudou no `.csproj`

$ cat Prazo.csproj
<Project Sdk="Microsoft.NET.Sdk">

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

  <ItemGroup>
    <PackageReference Include="Humanizer.Core.pt-BR" Version="3.0.10" />
  </ItemGroup>

</Project>

<ItemGroup>: Um grupo de itens novo (veja O Arquivo .csproj).
<PackageReference … />: "Referência de pacote": o projeto usa este pacote.
Include="Humanizer.Core.pt-BR": Qual pacote.
Version="3.0.10": Qual versão. Ela fica anotada para que, em qualquer máquina, o projeto use a mesma versão.

O dotnet package add é só um atalho para escrever essa linha (e restaurar). Você também pode escrevê-la à mão no .csproj: o próximo dotnet build baixa o pacote.

A ordem antiga: em tutoriais e no .NET 8, o comando é dotnet add package Nome. No .NET 10 ele continua funcionando e faz exatamente o mesmo; a forma nova, dotnet package add, junta todos os comandos de pacote debaixo de dotnet package (add, list, remove, search).

3. Usar o pacote

using Humanizer;

Console.WriteLine(TimeSpan.FromDays(3).Humanize());
Console.WriteLine(TimeSpan.FromMinutes(90).Humanize(2));
Console.WriteLine(1234.ToWords());
Console.WriteLine("caderno".ToQuantity(3));
Console.WriteLine("lápis".ToQuantity(1));

$ dotnet run
3 dias
1 hora, 30 minutos
mil duzentos e trinta e quatro
3 cadernos
1 lápi

using Humanizer;: O pacote trouxe um namespace novo, Humanizer. Sem este using, nada funciona (veja "Quando dá errado").
TimeSpan.FromDays(3).Humanize(): Humanize ("humanizar") é um método de extensão que o pacote acrescentou ao TimeSpan (veja Métodos de Extensão). Ele escreveu "3 dias" em português porque a máquina da Ana está em pt-BR (veja Cultura).
.Humanize(2): Com até 2 partes: "1 hora, 30 minutos".
1234.ToWords(): "Para palavras": o número por extenso. Útil para cheques e recibos.
"caderno".ToQuantity(3): "Para quantidade": põe o número e o plural.
"lápis".ToQuantity(1) → 1 lápi: Errado! Para o singular, o Humanizer tirou o "s" do fim, como se faz em inglês (pencils → pencil). As traduções do pacote cobrem os números e os tempos, mas o plural das palavras segue as regras do inglês. Lição: um pacote famoso também tem limites. Teste o que você vai usar.

Para o plural, a Ana decidiu escrever a própria função: dizer o singular e o plural, e escolher pelo número. Experimente:

Missão: a função Quantidade abaixo só acrescenta um "s", e erra quase tudo ("1 cadernos", "1 lápiss", "2 pãos"). Mude o return para usar o singular quando n == 1 e o plural nos outros casos (dica: o operador ? :, veja Operador Ternário). A saída tem de ser exatamente 1 caderno, 3 cadernos, 1 lápis e 2 pães.

Console.WriteLine(Quantidade(1, "caderno", "cadernos"));
Console.WriteLine(Quantidade(3, "caderno", "cadernos"));
Console.WriteLine(Quantidade(1, "lápis", "lápis"));
Console.WriteLine(Quantidade(2, "pão", "pães"));

static string Quantidade(int n, string singular, string plural)
{
    return $"{n} {singular}s";
}

Console.WriteLine(Quantidade(1, "caderno", "cadernos"));
Console.WriteLine(Quantidade(3, "caderno", "cadernos"));
Console.WriteLine(Quantidade(1, "lápis", "lápis"));
Console.WriteLine(Quantidade(2, "pão", "pães"));

static string Quantidade(int n, string singular, string plural)
{
    return $"{n} {(n == 1 ? singular : plural)}";
}

4. Onde os pacotes ficam

O pacote não fica dentro do projeto. Ele vai para uma pasta da Ana, compartilhada por todos os projetos dela:

$ ls ~/.nuget/packages/
humanizer.core
humanizer.core.pt-br
microsoft.aspnetcore.app.ref
microsoft.dotnet.ilcompiler
microsoft.netcore.app.host.linux-x64
microsoft.netcore.app.ref
microsoft.net.illink.tasks
runtime.linux-x64.microsoft.dotnet.ilcompiler
$ ls ~/.nuget/packages/humanizer.core/3.0.10
analyzers
buildTransitive
humanizer.core.3.0.10.nupkg
humanizer.core.3.0.10.nupkg.sha512
humanizer.core.nuspec
lib
logo.png

~/.nuget/packages/: O "depósito" de pacotes da Ana. A pasta começa com ponto, então fica escondida no ls ~ comum. Os outros nomes da lista vieram de outros testes da Ana (o projeto para o .NET 8 da aula O Arquivo .csproj, por exemplo): o próprio .NET também usa pacotes por baixo.
humanizer.core/3.0.10: Uma pasta por pacote (em minúsculas) e, dentro, uma por versão. Dois projetos que usam a mesma versão usam a mesma cópia: o download acontece uma vez só.
.nupkg: O pacote original, como veio do nuget.org. Na verdade, é um arquivo .zip com outro nome.
lib: As .dll que o seu programa usa.
.nuspec: A "ficha" do pacote: nome, versão, autor, dependências.

Restaurar em outra máquina

Como os pacotes não ficam no projeto, quem copia o projeto (por exemplo, com o Git) recebe só o .csproj com as linhas PackageReference. Não tem problema: o build, o run e o test restauram sozinhos. A Ana simulou isso apagando as pastas geradas:

$ rm -rf bin obj
$ dotnet build | head -3
  Determinando os projetos a serem restaurados...
  /home/ana/projetos/Prazo/Prazo.csproj restaurado (em 442 ms).
  Prazo -> /home/ana/projetos/Prazo/bin/Debug/net10.0/Prazo.dll

Por isso as pastas bin e obj nunca vão para o Git: tudo o que está nelas o dotnet refaz. O dotnet new gitignore cria um arquivo .gitignore que já as deixa de fora.

5. Versões

Escolher a versão: `--version`

Às vezes você precisa de uma versão específica (um tutorial antigo, um colega que usa outra). A Ana voltou para a 3.0.1:

$ dotnet package add Humanizer.Core.pt-BR --version 3.0.1
«…»
info : PackageReference do pacote 'Humanizer.Core.pt-BR' versão '3.0.1' atualizada no arquivo '/home/ana/projetos/Prazo/Prazo.csproj'.
«…»

Como o pacote já estava no projeto, a linha foi atualizada (não duplicada). As versões seguem o formato MAIOR.MENOR.CORREÇÃO: de 3.0.1 para 3.0.10 são só correções; de 2.x para 3.x, mudanças que podem quebrar o seu código.

O que está desatualizado: `--outdated`

$ dotnet package list --outdated
  Determinando os projetos a serem restaurados...
  /home/ana/projetos/Prazo/Prazo.csproj restaurado (em 395 ms).

As fontes a seguir foram usadas:
   https://api.nuget.org/v3/index.json

O projeto 'Prazo' tem as seguintes atualizações para seus pacotes
   [net10.0]:
   Pacote de Nível Superior      Solicitado   Resolvido   Mais Recente
   > Humanizer.Core.pt-BR        3.0.1        3.0.1       3.0.10

Pacote de Nível Superior: Os pacotes que você pediu (os do .csproj).
Solicitado / Resolvido: A versão escrita no .csproj e a que o NuGet de fato usou. Quase sempre são iguais.
Mais Recente: A mais nova no nuget.org.

Para atualizar para a mais nova, basta rodar o add de novo, sem --version:

$ dotnet package add Humanizer.Core.pt-BR
«…»
info : PackageReference do pacote 'Humanizer.Core.pt-BR' versão '3.0.10' atualizada no arquivo '/home/ana/projetos/Prazo/Prazo.csproj'.
«…»
$ grep PackageReference Prazo.csproj
    <PackageReference Include="Humanizer.Core.pt-BR" Version="3.0.10" />

As dependências das dependências: `--include-transitive`

$ dotnet package list --include-transitive
  Determinando os projetos a serem restaurados...
  Todos os projetos estão atualizados para restauração.
O projeto 'Prazo' tem as seguintes referências de pacote
   [net10.0]:
   Pacote de Nível Superior      Solicitado   Resolvido
   > Humanizer.Core.pt-BR        3.0.10       3.0.10

   Pacote Transitivo      Resolvido
   > Humanizer.Core       3.0.10

Um pacote transitivo é o que veio "de carona": a Ana não pediu o Humanizer.Core, mas o pt-BR precisa dele. Sem --include-transitive, o dotnet package list mostra só a primeira tabela.

Pacotes perigosos: `NU1903` e `--vulnerable`

Pacotes antigos podem ter falhas de segurança conhecidas. O NuGet confere uma lista pública de falhas a cada restauração (eram aquelas linhas de "vulnerabilidades" do add). A Ana instalou de propósito uma versão velha do Newtonsoft.Json, um pacote de JSON muito usado:

$ dotnet package add Newtonsoft.Json --version 12.0.1
«…»
warn : NU1903: O pacote 'Newtonsoft.Json' 12.0.1 tem uma alta vulnerabilidade de gravidade conhecida, https://github.com/advisories/GHSA-5crp-9r3c-p9vr
«…»
$ dotnet package list --vulnerable
  Determinando os projetos a serem restaurados...
/home/ana/projetos/Prazo/Prazo.csproj : warning NU1903: O pacote 'Newtonsoft.Json' 12.0.1 tem uma alta vulnerabilidade de gravidade conhecida, https://github.com/advisories/GHSA-5crp-9r3c-p9vr
  Todos os projetos estão atualizados para restauração.

As fontes a seguir foram usadas:
   https://api.nuget.org/v3/index.json

O projeto `Prazo` tem os pacotes vulneráveis a seguir
   [net10.0]:
   Pacote de Nível Superior      Solicitado   Resolvido   Severidade   URL do aviso
   > Newtonsoft.Json             12.0.1       12.0.1      High         https://github.com/advisories/GHSA-5crp-9r3c-p9vr

O aviso NU1903 ("vulnerabilidade de gravidade alta") aparece também em todo dotnet build, até você atualizar. O link explica a falha e diz a partir de qual versão ela foi corrigida. O conserto é atualizar (dotnet package add Newtonsoft.Json, sem versão) ou, como a Ana nem usava o pacote, removê-lo.

6. Remover: `dotnet package remove`

$ dotnet package remove Newtonsoft.Json
info : Removendo PackageReference do pacote 'Newtonsoft.Json' do projeto '/home/ana/projetos/Prazo/Prazo.csproj'.
$ grep PackageReference Prazo.csproj
    <PackageReference Include="Humanizer.Core.pt-BR" Version="3.0.10" />

O remove tira a linha do .csproj. A cópia em ~/.nuget/packages continua lá (outro projeto pode estar usando). Para limpar o depósito inteiro: dotnet nuget locals all --clear; os pacotes serão baixados de novo quando algum projeto precisar.

7. Pacotes num arquivo solto: `#:package` .NET 10

Num arquivo rodado com dotnet run arquivo.cs não há .csproj para pôr o PackageReference. No lugar dele, use a diretiva #:package Nome@Versão no começo do arquivo (como o #:property da aula O Arquivo .csproj):

#:package Humanizer.Core.pt-BR@3.0.10

using Humanizer;

foreach (int n in new[] { 7, 15, 100, 2026 })
{
    Console.WriteLine($"{n,5} = {n.ToWords()}");
}

$ dotnet run numeros.cs
    7 = sete
   15 = quinze
  100 = cem
 2026 = dois mil e vinte e seis

#:package: "Pacote": uma diretiva que só o dotnet run de arquivo solto entende. Ela vem antes de todo o resto, até dos using.
Humanizer.Core.pt-BR@3.0.10: O nome, uma arroba e a versão. O primeiro dotnet run baixa o pacote (se ele ainda não estiver em ~/.nuget/packages).

É ótimo para scripts pequenos: um arquivo só, que qualquer pessoa com o .NET 10 roda, e os pacotes vêm sozinhos.

Quando dá errado

Nome errado: Não há versões disponíveis do pacote

$ dotnet package add Humanizr
info : Adicionando PackageReference do pacote 'Humanizr' ao projeto '/home/ana/projetos/Prazo/Prazo.csproj'.
info :   NotFound https://api.nuget.org/v3/registration5-gz-semver2/humanizr/index.json 244 ms
info :   NotFound https://api.nuget.org/v3/registration5-gz-semver2/humanizr/index.json 99 ms
error: Não há versões disponíveis do pacote 'Humanizr'.

O que aconteceu: não existe pacote com esse nome (NotFound = "não encontrado"). Faltou o e de Humanizer. O .csproj não foi mudado.

Como resolver: confira o nome com dotnet package search ou no nuget.org, e copie de lá.

error: NU1102: Não é possível encontrar o pacote … com a versão (>= 9.9.9)

$ dotnet package add Humanizer.Core.pt-BR --version 9.9.9
info : Adicionando PackageReference do pacote 'Humanizer.Core.pt-BR' ao projeto '/home/ana/projetos/Prazo/Prazo.csproj'.
info : Restaurando pacotes para /home/ana/projetos/Prazo/Prazo.csproj...
error: NU1102: Não é possível encontrar o pacote Humanizer.Core.pt-BR com a versão (>= 9.9.9)
error:   - Encontradas 6 versões em nuget.org [Versão mais próxima: 3.0.10]
error:   - Encontradas 0 versões em /usr/lib/dotnet/library-packs
error: O pacote 'Humanizer.Core.pt-BR' é incompatível com as estruturas 'tudo' no projeto '/home/ana/projetos/Prazo/Prazo.csproj'.

O que aconteceu: o pacote existe, mas não nessa versão. A mensagem ajuda: há 6 versões no nuget.org, e a mais próxima é a 3.0.10. (A /usr/lib/dotnet/library-packs é uma segunda "loja", local, que o .NET do Ubuntu também consulta.) A última linha é consequência da primeira, e o .csproj ficou como estava.

Como resolver: use uma versão que existe (a lista fica na página do pacote no nuget.org) ou tire o --version.

error CS1061: ‘TimeSpan’ não contém uma definição para "Humanize"

$ dotnet build 2>&1 | grep -E " error " | sort -u | head -1
/home/ana/projetos/Prazo/Program.cs(2,40): error CS1061: ‘TimeSpan’ não contém uma definição para "Humanize" e não foi possível encontrar nenhum método de extensão "Humanize" que aceite um primeiro argumento do tipo ‘TimeSpan’ (você está se esquecendo de usar uma diretiva ou uma referência de assembly?) [/home/ana/projetos/Prazo/Prazo.csproj]

O que aconteceu: a Ana apagou o using Humanizer;. O pacote está instalado, mas os métodos de extensão dele só aparecem com o using do namespace. A própria mensagem desconfia: "você está se esquecendo de usar uma diretiva (using) ou uma referência de assembly (o pacote)?". Em inglês: 'TimeSpan' does not contain a definition for 'Humanize'. O mesmo erro aparece se o pacote não estiver no .csproj.

Como resolver: confira as duas coisas: o using Humanizer; no arquivo e a linha PackageReference no .csproj (dotnet package list). Se fosse uma classe do pacote (não um método de extensão), o erro seria o CS0246 ("o nome do tipo não pode ser encontrado").

Sem internet: Resource temporarily unavailable (api.nuget.org:443)

$ dotnet package add Spectre.Console
«… as duas linhas dos certificados …»
info : Adicionando PackageReference do pacote 'Spectre.Console' ao projeto '/home/ana/projetos/Prazo/Prazo.csproj'.
info :   GET https://api.nuget.org/v3/registration5-gz-semver2/spectre.console/index.json
info : Foi encontrado um erro ao buscar 'GET https://api.nuget.org/v3/registration5-gz-semver2/spectre.console/index.json'. A solicitação agora será repetida.
info : Resource temporarily unavailable (api.nuget.org:443)
info :   Resource temporarily unavailable
«… mais uma tentativa igual …»
info :   GET https://api.nuget.org/v3/registration5-gz-semver2/spectre.console/index.json
error: Resource temporarily unavailable (api.nuget.org:443)
error:   Resource temporarily unavailable

O que aconteceu: a Ana estava sem internet. O NuGet tentou três vezes falar com o api.nuget.org e desistiu ("recurso temporariamente indisponível"; 443 é a porta das conexões seguras, https).

Como resolver: conecte-se e tente de novo. Os pacotes que já estão em ~/.nuget/packages continuam funcionando sem internet; só os novos precisam dela.

Referência rápida

Comando	O que faz
`dotnet package search texto`	Procura pacotes no `nuget.org` (`--take N` limita).
`dotnet package add Nome`	Instala a versão mais nova (ou atualiza para ela).
`dotnet package add Nome --version 1.2.3`	Instala uma versão específica.
`dotnet package list`	Lista os pacotes do projeto.
`dotnet package list --include-transitive`	Inclui as dependências das dependências.
`dotnet package list --outdated`	Mostra o que tem versão mais nova.
`dotnet package list --vulnerable`	Mostra os pacotes com falhas de segurança conhecidas.
`dotnet package remove Nome`	Tira o pacote do projeto.
`dotnet restore`	Baixa o que faltar (o `build` já faz isso).
`dotnet nuget locals all --clear`	Esvazia o depósito `~/.nuget/packages` e os caches.
`<PackageReference Include="Nome" Version="1.2.3" />`	A linha do `.csproj`.
`#:package Nome@1.2.3`	O mesmo, num arquivo solto.

Exercícios

1. Instalar

Complete o comando que instala o pacote Spectre.Console:

dotnet package Spectre.Console

2. A linha do .csproj

Complete a linha que o add escreve no .csproj:

< Include="Spectre.Console" Version="0.50.0" />

3. Num arquivo solto

Complete a diretiva que traz o Humanizer em português, versão 3.0.10, para um arquivo solto:

Humanizer.Core.pt-BR@3.0.10

4. A Ana copiou o projeto Prazo para outro computador, sem as pastas bin e obj. O que acontece no primeiro dotnet build?

Falha, porque o pacote não veio junto. Compila sem o pacote e dá erro ao rodar. Restaura (baixa) o pacote da versão do .csproj e compila. Pede para rodar dotnet package add de novo.

5. O dotnet build mostra warning NU1903. O que isso quer dizer?

Que existe uma versão mais nova, só isso. Que a versão usada tem uma falha de segurança conhecida; é hora de atualizar. Que o pacote não existe. Que falta o using.

6. Onde o NuGet guarda os pacotes baixados no Linux?

Em ~/.nuget/packages, compartilhado por todos os projetos. Dentro da pasta bin de cada projeto. No próprio .csproj. Em /usr/lib/dotnet/sdk.

Resumo

Um pacote é código pronto para o seu programa usar; o nuget.org é a loja; o NuGet é a ferramenta.
dotnet package search procura; dotnet package add Nome instala e escreve <PackageReference Include="Nome" Version="…" /> no .csproj.
Os pacotes ficam em ~/.nuget/packages, não no projeto. O build restaura sozinho o que faltar.
Depois de instalar, falta o using do namespace do pacote.
--version escolhe a versão; list --outdated mostra o que atualizar; list --vulnerable e o aviso NU1903 mostram o que é perigoso.
dotnet package remove tira o pacote. Num arquivo solto, use #:package Nome@Versão.
Teste o que você usa: até um pacote famoso tem limites (o "1 lápi").

C# Pacotes NuGet

A ideia: a loja de aplicativos do programador

1. Procurar um pacote

2. Instalar: dotnet package add

O que mudou no .csproj

3. Usar o pacote

4. Onde os pacotes ficam

Restaurar em outra máquina

5. Versões

Escolher a versão: --version

O que está desatualizado: --outdated

As dependências das dependências: --include-transitive

Pacotes perigosos: NU1903 e --vulnerable

6. Remover: dotnet package remove

7. Pacotes num arquivo solto: #:package .NET 10

Quando dá errado

Referência rápida

Exercícios

1. Instalar

2. A linha do .csproj

3. Num arquivo solto

Resumo

2. Instalar: `dotnet package add`

O que mudou no `.csproj`

Escolher a versão: `--version`

O que está desatualizado: `--outdated`

As dependências das dependências: `--include-transitive`

Pacotes perigosos: `NU1903` e `--vulnerable`

6. Remover: `dotnet package remove`

7. Pacotes num arquivo solto: `#:package` .NET 10