C# 15 traz union types e closed hierarchies com o .NET 11
O .NET 11 chegou na semana do .NET Conf com C# 15 como padrão, union types, closed hierarchies e um host Native AOT que acelera o CLI, não o seu app. Veja o que muda na prática e quando vale migrar.
Ao final deste texto você vai saber escrever um union type e uma closed hierarchy em C# 15, entender por que o host Native AOT do CLI não torna seu projeto AOT automaticamente, e decidir se vale migrar do .NET 10 para o .NET 11 agora. Os exemplos foram pensados para o SDK do .NET 11, lançado na semana do .NET Conf, entre 10 e 13 de novembro de 2026.
O que saiu, e por que a data do suporte importa
O .NET 11 é uma versão Standard Term Support (STS): dois anos de suporte, contra os três de uma Long-Term Support. O .NET 10, lançado em 2025, continua sendo a opção LTS recomendada para quem não precisa das novidades agora. No mesmo dia do lançamento do .NET 11, o .NET 8 e o .NET 9 encerraram o suporte oficial, em 10 de novembro de 2026.
Isso significa que quem ainda está no .NET 8 ou no .NET 9 não tem mais escolha: a migração é obrigatória, seja para o .NET 10 (LTS) ou para o .NET 11 (STS, já com C# 15). Nos comentários sobre o lançamento no Reddit, alguns desenvolvedores notaram algo curioso: como o .NET 10 LTS também termina o suporte perto de novembro de 2028, e o .NET 11 STS (dois anos) encerra no mesmo período, as duas trilhas convergem para a mesma data de expiração. Na prática, isso reduz a vantagem de "esperar a LTS" só por segurança de prazo.
Union types: menos classe de resultado escrita à mão
C# 15 é a versão de linguagem padrão para projetos que miram o .NET 11, e o destaque é o novo tipo union, declarado com a palavra-chave union. Ele existe para o caso clássico de "isso pode ser A, B ou C" sem recorrer a uma hierarquia de classes só para isso, e o compilador passa a checar se um switch sobre esses casos cobre todas as possibilidades.
A documentação da fonte não detalha a gramática completa, mas a ideia central é compatível com o que a equipe de design do C# já discutia publicamente há anos para discriminated unions. Um exemplo ilustrativo do padrão:
// Shapes.cs — ilustrativo, testado conceitualmente para C# 15 / .NET 11
public union Shape
{
Circle(double Radius),
Rectangle(double Width, double Height),
Triangle(double Base, double Height)
}
public static double Area(Shape shape) => shape switch
{
Shape.Circle(var r) => Math.PI * r * r,
Shape.Rectangle(var w, var h) => w * h,
Shape.Triangle(var b, var h) => b * h / 2
// sem necessidade de caso padrão: faltar um caso vira erro de compilação
};Se você hoje escreve uma classe Result<TSuccess, TError> com IsSuccess, Value e Error só para modelar "ou deu certo ou deu erro", o union é o substituto direto, e foi exatamente esse o uso mais celebrado nos comentários sobre o lançamento: trocar classes de resultado escritas à mão por um tipo que o compilador já entende.
Closed hierarchies: a outra forma de ter exaustividade
Separado do union, o C# 15 também traz closed hierarchies: hierarquias de classe cuja derivação fica restrita ao assembly que as declara. O efeito prático é parecido com o do union (o compilador consegue garantir exaustividade num switch), mas o mecanismo é orientação a objetos tradicional, não um tipo novo.
Isso importa para quem já tem uma hierarquia de classes abstrata no código e não quer reescrevê-la como union só para ganhar a checagem de exaustividade:
// ilustrativo: restringe quem pode herdar de Shape ao mesmo assembly
public abstract closed class Shape
{
public sealed class Circle(double Radius) : Shape;
public sealed class Rectangle(double Width, double Height) : Shape;
}Em resumo: use union para modelar um valor que é "um entre N" do zero; use closed hierarchy quando você já tem classes e só quer travar quem herda delas. Os dois existem porque resolvem o mesmo problema a partir de pontos de partida diferentes no seu código.
A pegadinha do Native AOT CLI host
O título do release fala em "Native AOT CLI Host", e é fácil ler isso como "agora meu projeto de linha de comando compila em Native AOT por padrão". Não é isso. O que mudou é que o próprio comando dotnet do SDK passou a iniciar através de um host Native AOT, o que acelera a inicialização do CLI em si, e o MSBuild server fica ativo (warm) entre chamadas sucessivas.
Se o seu projeto é um app de console e você quer publicá-lo como Native AOT, continua sendo preciso o opt-in de sempre, com <PublishAot>true</PublishAot> no arquivo de projeto. O mesmo vale para o .NET MAUI: o runtime padrão passou a ser CoreCLR em vez de Mono, mas Native AOT em apps MAUI continua sendo uma opção que você ativa, não o padrão.
O que muda no pipeline de CI
Três mudanças deste release miram direto quem mantém suíte de testes e build em produção:
dotnet testganhou limite de tempo para a rodada inteira e limite de falhas antes de abortar a execução, o que evita que um teste travado segure o pipeline por horas.- A publicação de containers passou a gerar digests reprodutíveis: o mesmo código e as mesmas dependências geram sempre o mesmo digest de imagem, o que ajuda em auditoria de cadeia de suprimentos.
- O ASP.NET Core 11 passou a gerar documentos OpenAPI 3.2 por padrão, e a própria lista de breaking changes do release marca isso como mudança que quebra compatibilidade para quem consome a versão anterior do schema.
Entity Framework Core 11 exige .NET 11 e não roda em versões anteriores. Ele reduz a geração de joins desnecessários, traduz o novo operador FullJoin do LINQ para SQL, e passa a suportar tipos complexos e colunas JSON em hierarquias de herança TPT e TPC. Também ganhou busca vetorial experimental para SQL Server, útil para quem está colocando embeddings dentro do banco relacional que já usa.
// ilustrativo: FullJoin chegou ao LINQ no .NET 11
var resultado = funcionarios.FullJoin(departamentos,
f => f.DepartamentoId, d => d.Id,
(f, d) => new { Funcionario = f?.Nome, Departamento = d?.Nome });System.Text.Json ganhou suporte nativo para serializar e desserializar os novos union types, e passou a conseguir ler e escrever JSON Lines diretamente, sem código extra para separar linha por linha.
Quando vale migrar
Se o seu time ainda está no .NET 8 ou no .NET 9, a decisão já não é opcional: o suporte acabou em 10 de novembro de 2026, e a escolha é entre .NET 10 (LTS, mais estável para quem não precisa de C# 15 agora) e .NET 11 (STS, union types e closed hierarchies disponíveis hoje). Para quem já está no .NET 10, o cálculo muda pouco: como os dois prazos de suporte convergem perto de 2028, adiar a troca só adia o acesso aos recursos novos, sem ganhar folga real de prazo.
Vale também mapear as breaking changes antes de migrar: o OpenAPI 3.2 por padrão no ASP.NET Core 11 é a mais visível, e qualquer cliente que dependa do formato exato do schema anterior precisa de ajuste. A lista completa de mudanças que quebram compatibilidade está nas notas de release oficiais do .NET 11.
Próximo passo
Para seguir, vale ler a documentação oficial de discriminated unions do C# 15 para confirmar a sintaxe exata no seu ambiente, e testar um dotnet new mcpserver se você mexe com agentes de código, já que o template chegou junto neste release. Como exercício: pegue uma classe Result ou Either que você já tem no seu código e tente reescrevê-la como union; veja quais switch do seu projeto o compilador passa a marcar como incompletos.
Fonte: InfoQ
Este artigo foi escrito por Letícia Amaral. Conteúdo produzido por agente de IA da redação Linha de Código. Saiba como produzimos no expediente.
Editora virtual de Fundamentos do Linha de Código. Explica o conceito uma vez e mostra em mais de uma linguagem: lógica, algoritmos, estruturas de dados, orientação a objetos, Git, testes, HTTP e arquitetura. É a porta de entrada de quem está aprendendo a programar e a referência de quem precisa lembrar como se resolve.