Acelerando o .NET: Análise de Performance do Core 3.1 ao 8

Desde a chegada do .NET Core, a Microsoft tem lançado atualizações anuais que turbinam o Framework. Uma das melhorias mais legais é na velocidade das aplicações. Comparando o .NET Core 3.1 com o .NET 8, temos um ganho real de desempenho. Isso significa que suas aplicações vão rodar mais rápido e suave, economizando memória e melhorando a experiência do usuário ao atualizar para a tecnologia mais recente.

Para tirar algumas conclusões, foram feitos experimentos com as versões dos últimos 5 anos:

• .NET CORE 3.1 (3 de dezembro de 2019)
• .NET 5 (10 de novembro de 2020)
• .NET 6 (8 de novembro de 2021)
• .NET 7 (8 de novembro de 2022)
• .NET 8 (14 de novembro de 2023)

Para garantir que um teste de performance seja abrangente, é essencial cobrir uma variedade de cenários. Isso porque cada atualização do Framework .NET melhora aspectos diferentes. Neste estudo, focaremos em situações típicas do desenvolvimento web, como:

• Serialização e desserialização de JSON: essenciais para a comunicação de dados na web.
• Operações com coleções: variadas e frequentes no manuseio de dados.

Utilizamos a ferramenta BenchmarkDotNet, uma biblioteca open-source de referência para avaliação de desempenho, que nos fornece dados concretos sobre o comportamento da aplicação nas diferentes versões do .NET.

Execução dos testes

Cenário 1 — Serialização de objeto em JSON

Para efetuar os testes de serialização JSON, desenvolvemos duas estruturas distintas: a primeira, uma classe básica contendo três propriedades fundamentais — um inteiro, uma string e um booleano; a segunda, uma classe complexa que, além de incorporar dois elementos da classe básica, agrega uma lista composta por instâncias da classe básica. Essa abordagem nos permite avaliar o desempenho da serialização em cenários de complexidade variada.

public class ClasseSimples
{
    public int Id { get; set; }
    public string Descricao { get; set; }
    public bool Sucesso { get; set; }
}

public class ClasseComposta
{
    public int Id { get; set; }
    public string Descricao { get; set; }
    public List<ClasseSimples> Conteudo { get; set; }
}

Para cada uma das classes, foram testadas 4 operações:

• Serialização de objeto da classe simples e composta
• Serialização de lista com 10 registros da classe simples e composta
• Serialização de lista com 100 registros da classe simples e composta
• Serialização de lista com 1000 registros da classe simples e composta

Para o atributo Conteudo da lista ClasseComposta, foi fixado uma lista sempre com 5 registros, para não gerar uma divergência indesejada nos testes.

Os resultados para os testes de serialização estão exibidos abaixo:

Fazendo um compilado dos resultados, podemos ver uma diferença de performance entre 30% e 50% se compararmos a versão .NET Core 3.1 para a versão .NET 8, a depender da quantidade de registros na lista serializada e tamanho.

Cenário 2 — Desserialização de JSON em objeto

Nos testes de desserialização de JSON, usamos as mesmas estruturas dos testes de serialização. O processo é o inverso: a partir do JSON que foi gerado anteriormente, recriamos as classes originais com todos os dados corretamente preenchidos. Veja a seguir alguns exemplos de JSON que utilizamos.

ClasseSimples

{
 "Id": 0,
 "Descricao": "Teste",
 "Sucesso": false
}

ClasseComposta

{
 "Id": 0,
 "Descricao": "Teste",
 "Conteudo": [
  {
   "Id": 0,
   "Descricao": "1531354112",
   "Sucesso": false
  },
  {
   "Id": 1,
   "Descricao": "2094429423",
   "Sucesso": true
  },
  {
   "Id": 2,
   "Descricao": "477741787",
   "Sucesso": false
  },
  {
   "Id": 3,
   "Descricao": "1385728650",
   "Sucesso": false
  },
  {
   "Id": 4,
   "Descricao": "1805940613",
   "Sucesso": true
  }
 ]
}

O resultado do teste de desserialização segue abaixo:

Neste cenário vemos ainda maior impacto entre as versões .NET Core 3.1 e .NET 8, com economia de tempo entre 45% e 60%.

Cenário 3 — Operações em diferentes coleções

Aqui focaremos nas coleções mais usadas no .NET: List, Dictionary e Array. Para cada tipo de coleção, realizaremos operações comuns como:

• Adicionar um único elemento.
• Adicionar uma lista de elementos.
• Obter primeiro elemento.
• Obter ultimo elemento.
• Buscar um elemento específico.

Para a análise, será utilizada a Classe Simples dos cenários anteriores, e a manipulação das coleções serão sempre com um conjunto de 30 elementos.

Os resultados da execução se encontram abaixo:

Os resultados revelaram uma economia significativa de tempo, com uma melhoria de 65% no processamento ao comparar o uso de coleções na versão .NET Core 3.1 com a versão .NET 8.

Conclusão

A transição para as versões mais recentes do .NET, desde o .NET Core 3.1 até o .NET 8, revela um salto notável em eficiência, com ganhos de desempenho que variam entre 30% e 65% em operações críticas como serialização e desserialização de JSON e manipulação de coleções. Essas melhorias refletem diretamente na agilidade e na economia de recursos das aplicações, reforçando a importância de manter as tecnologias atualizadas para maximizar a performance e oferecer a melhor experiência possível aos usuários. Portanto, a atualização para o .NET 8 surge como uma decisão estratégica muito importante para desenvolvedores que visam excelência e competitividade no mercado digital.

Referências

Política de Suporte do .NET e do .NET Core

BenchmarckDotnet.org