.NET 10 - Liberada a versão RC1 com licença go-Live

   Hoje apresenta a versão RC1 do .NET 10 (LTS) liberada com a licença go-Live.

A Microsoft acabou de lançar o .NET 10 RC1 e vou te apresentar uma visão geral desta versão e te motivar a trocar para o .NET 10.



O .NET 10 Release Candidate combina muitas melhorias “invisíveis” com apostas grandes no futuro. Se você acompanhou os previews, especialmente o Preview 7, que trouxe grandes recursos , vai concordar que este é um dos lançamentos mais completos para uma versão do .NET.

Cabe destacar que esta versão RC1 não é apenas um preview simples, pois vem com licença go-live, o que significa que a Microsoft te dá suporte oficial caso decida usá-lo em produção. Isso é fundamental, porque indica que a plataforma já está estável e pronta para projetos reais.

Assim, esta não é apenas "mais uma atualização anual". É um lançamento que faz o .NET parecer mais poderoso — e mais agradável — para a construção de aplicativos modernos. 

O .NET 10 foca em três áreas que realmente importam no desenvolvimento do dia a dia:

1 - Melhoria de desempenho sem alterar seu código
2 - Segurança preparada para o futuro quântico
3 - APIs mais modernas e práticas

Desempenho: melhorias que você nota sem fazer nada

a-Desvirtualização de arrays que realmente funciona

Antes, quando você acessava um array através de IEnumerable<T>, o JIT gerava chamadas virtuais desnecessárias. No .NET 10, o compilador reconhece que se trata de um array e otimiza automaticamente:

// Este código agora é mais rápido sem alterações
public class TesteDesvirtualizacao
{
    private int[] numeros = Enumerable.Range(0, 1_000_000).ToArray();
    [Benchmark]
    public long Somar_ArrayIEnumerable() => numeros.AsEnumerable().Sum();
}

Faça  um teste e verifique que a diferença é notável. É uma daquelas otimizações que melhoram seu código existente sem que você precise mudar nada.

b - Alocação na pilha que realmente funciona

Outra melhoria importante é a alocação automática na pilha para pequenos arrays, o que reduz significativamente a pressão no coletor de lixo:

// Agora isso é ainda mais eficiente
Span<int> buffer = stackalloc int[64];
for (int i = 0; i < 64; i++) 
{
    buffer[i] = i;
}

Se você trabalha com algoritmos de parsing ou criptografia ou em projetos onde cada microssegundo conta, essas otimizações fazem a diferença.

Preparação para o hardware do futuro

O .NET 10 já inclui suporte a instruções AVX10.2 e GFNI, que nem existem ainda nos processadores atuais. A Microsoft se adiantou para que, quando o hardware compatível chegar, o ecossistema .NET já esteja pronto para aproveitá-lo desde o primeiro dia.

Isso mostra uma visão de longo prazo, algo que é muito importante em uma plataforma de desenvolvimento.

Nota:

  • AVX10.2: A próxima evolução das instruções SIMD da Intel. Não é um novo conjunto, mas uma arquitetura unificada que consolida e padroniza os recursos AVX (AVX2, AVX-512) para futuros processadores, garantindo que uma base comum de instruções avançadas esteja disponível em todos os núcleos (P-cores e E-cores).

  • GFNI: Um conjunto de instruções especializado para operações de campo de Galois (Galois Field), extremamente útil para criptografia, checksums, correção de erros e processamento de bits. Pode ser acelerado tanto em unidades de inteiros (SSE) quanto de vetores (AVX).

APIs mais modernas na BCL (Base Class Library)

Conversões simplificadas UTF-8 ↔ Hexadecimal

Um dos aprimoramentos mais práticos são as novas APIs para trabalhar com dados binários e hexadecimais:


ReadOnlySpan<byte> dados = stackalloc byte[] { 0xDE, 0xAD, 0xBE, 0xEF };
string hexadecimal = Convert.ToHexString(dados); // "DEADBEEF"

Isso elimina muito código repetitivo em tarefas de criptografia e serialização. Menos alocações e menos complexidade.

Suporte a PipeReader na serialização JSON

O Preview 7 trouxe suporte a PipeReader no System.Text.Json. Agora é possível serializar e desserializar JSON diretamente de um PipeReader, o que é traz uma vantagem enorme em termos de desempenho:

// Agora você pode desserializar diretamente de um PipeReader
var leitor = PipeReader.Create(stream);
var resultado = await JsonSerializer.DeserializeAsync<MeuModelo>(leitor);
 

O desempenho com cargas grandes de JSON e a redução no uso de memória é significativa. Isso é particularmente útil em cenários de alta demanda, como APIs web e mensageria em tempo real, onde minimizar sobrecarga é crucial.

Abstração WebSocketStream

Outra adição prática é o WebSocketStream, que fornece uma abstração de stream sobre WebSockets. Isso simplifica os padrões de leitura e escrita em aplicações em tempo real:


using var fluxoWebSocket = new WebSocketStream(webSocket);
await fluxoWebSocket.WriteAsync(dados);

Melhorias em coleções e datas

Foram adicionados OrderedDictionary<TKey,TValue>, melhorias no TimeSpan e DateOnly com suporte aprimorado a ISOWeek. São pequenos detalhes que tornam o desenvolvimento mais fluido.

Criptografia pós-quântica: preparando o futuro

Por que isso é revolucionário ?

O recurso mais disruptivo do .NET 10 é o suporte nativo a algoritmos de criptografia pós-quântica. A partir do Preview 7, a Microsoft introduziu ML-DSA (algoritmo de assinatura digital baseado em aprendizado de máquina) e suas variantes compostas, junto ao já existente ML-KEM e SLH-DSA:

// Criptografia do futuro, disponível hoje
using var kem = MLKem.Create();
var (publica, privada) = kem.GenerateKeyPair();
var cifra = kem.Encapsulate(publica, out var segredo);
var recuperado = kem.Decapsulate(privada, cifra);

// Novo suporte ML-DSA
using var dsa = MLDSA.Create();
var assinatura = dsa.Sign(dados, chavePrivada);
bool valido = dsa.Verify(dados, assinatura, chavePublica);

Ainda é experimental, mas o fato de já estar diretamente na BCL mostra que a Microsoft leva isso muito a sério.

Padrões criptográficos aprimorados

- Suporte ao AES KeyWrap com Padding (IETF RFC 5649).
- Suporte a TLS 1.3 em clientes macOS, melhorando segurança e performance.

ASP.NET Core e Blazor mais produtivos
Processamento JSON que realmente escala

O suporte a PipeReader no System.Text.Json é um divisor de águas para aplicações ASP.NET Core. Ele reduz alocações de memória e melhora o desempenho em cargas grandes:

// Processamento JSON de alto desempenho no ASP.NET Core
app.MapPost("/dados", async (PipeReader leitor) =>
{
    var modelo = await JsonSerializer.DeserializeAsync<ModeloDeDados>(leitor);
    return Results.Ok(modelo);
});

Melhorias em autenticação

Melhor suporte a chaves de acesso (passkeys) para login sem senha.

Melhor detecção de endpoints de API (sem redirecionamento para login HTML quando se usa cookies).

// Melhor detecção de endpoints de API
app.UseAuthentication();
app.UseAuthorization();

Melhorias na experiência de desenvolvimento

- Suporte ao domínio .localhost para simplificar configurações locais.
- Blazor com validação aprimorada para classes e records.
- Uso interno de PipeReader para melhor desempenho em componentes.
- Dependência do OpenAPI.NET atualizada para versão estável.

EF Core 10: JSON e tipos complexos

O Entity Framework Core 10 traz melhorias importantes como:

- Suporte otimizado a dados JSON em consultas.
- Melhor suporte a tipos complexos.

Isso é essencial para quem trabalha com PostgreSQL ou SQL Server em modelos híbridos.

Algo importante que você deve saber

- Para usar o net10.0, é necessário ter versões recentes do Visual Studio 2026 ou o SDK atualizado.
- O analisador de trimming agora limita iterações de análise de fluxo de controle, o que melhora estabilidade e reduz builds longos.

Recursos úteis

 Download do .NET 10 RC1 — site oficial (Essa versão só é compatível com Visual Studio 2026 (v18.0 Preview 1).
Documentação de novidades — todos os recursos novos
Visual Studio 2026 Insiders (Para usar com o .NET 10)

E estamos conversados...  

"(Disse Jesus) Estai em mim, e eu em vós; como a vara de si mesma não pode dar fruto, se não estiver na videira, assim também vós, se não estiverdes em mim."
João 15:4

Referências:

José Carlos Macoratti