Melhorias de desempenho do LINQ no .NET 9.0

Melhorias de desempenho do LINQ no .NET 9.0

• Iteração com Span<T>

  • No .NET 9.0, o desempenho do LINQ foi significativamente melhorado.
  • Ao iterar arrays usando Span<T>, o desempenho melhora.
  • O método TryGetSpan() converte arrays ou listas em ReadOnlySpan<T> para aumentar a velocidade de iteração.

• Método TryGetSpan()

  • TryGetSpan() melhora o desempenho da iteração ao converter arrays ou listas em ReadOnlySpan<T>.
  • A otimização do código acontece em detalhes sutis, e o código foi escrito por especialistas em desempenho.
  • Como o array interno da lista pode ser alterado, é preciso ter cuidado ao usar CollectionsMarshal.AsSpan().

• Chamadores de TryGetSpan()

  • Ao analisar os métodos que chamam TryGetSpan(), observa-se que muitos métodos de Enumerable tentam usar spans quando a origem é um array ou uma lista.
  • Operações que usam yield não podem aproveitar essa otimização.

• Iteradores especializados

  • O desempenho foi melhorado ao unificar as classes internas de iteradores do LINQ baseadas em IIListProvider e IPartition.
  • São gerados iteradores especializados que reconhecem determinadas cadeias de chamadas do LINQ e as processam de forma eficiente.

• Implementação de Iterator<T> e classes derivadas

  • Iterator<T> é uma classe abstrata, e as classes derivadas sobrescrevem apenas os métodos necessários.
  • ListWhereSelectIterator<TSource, TResult> melhora o desempenho ao tratar a cadeia Where(...).Select(...) com um único iterador.

• Estudo de caso de IListSkipTakeIterator<TSource>

  • O método MoveNext() evita iterações desnecessárias e processa apenas os elementos dentro do intervalo de _minIndexInclusive e _maxIndexInclusive.

Resumo do GN⁺

• No .NET 9.0, o desempenho do LINQ foi significativamente melhorado, especialmente com o uso de Span<T> e TryGetSpan() para acelerar a iteração.
• A estrutura interna do LINQ foi otimizada para reconhecer cadeias específicas de chamadas e gerar iteradores especializados que as processam com eficiência.
• Essas melhorias ajudam a aumentar o desempenho do código, e migrar para uma versão mais recente do .NET permite aproveitar esses benefícios.
• Outra biblioteca que oferece funcionalidades semelhantes ao LINQ é System.Linq.Async.

[GN⁺]

Comentários do Hacker News

• A parte mais útil do LINQ é a extensão de IEnumerable. Isso permite escrever C# em um estilo funcional

  • Depois de aprender Haskell, os conceitos do LINQ passaram a fazer sentido
  • Quando usado por equipes sem experiência, pode resultar em código complexo e lento

• Não dá para entender por que a equipe do dotnet não investe mais recursos nas ferramentas

  • Foi mencionada a necessidade de geração de documentação, testes unitários melhores e melhoria na acessibilidade do código-fonte
  • A maioria dos pacotes no NuGet carece de documentação

• As melhorias de desempenho do LINQ estão focadas nas melhorias de desempenho da própria implementação de List<T> da Microsoft

  • Foi enfatizada a necessidade de investir na redução de alocações de lambdas e do tempo de compilação
  • Foi mencionada a necessidade de suporte a curingas em variáveis do LINQ

• O LINQ é um dos principais fatores de diferenciação entre linguagens

  • Quase não mudou desde o C# 3
  • É uma pena pensar que o LINQ só é útil para iterar listas

• Quanto mais o C# toma emprestado do F#, melhor

  • Há expectativa de que unions discriminadas sejam introduzidas no C#

• Sente-se falta do LINQ ao usar outras linguagens

  • Ter LINQ na biblioteca padrão é uma grande vantagem

• Depois que você começa a usar LINQ, fica difícil usar outra coisa

• É difícil encontrar material abrangente para aprender desenvolvimento web com dotnet

  • A maior parte do material é muito básica ou de baixa qualidade

• As anotações no código moderno de .NET são complexas demais

  • É preciso uma abordagem melhor

• Há uma seção sobre melhorias de desempenho no .NET 9

  • Foi mencionada a possibilidade de mais otimizações em cadeias que terminam com determinados métodos

• OrderBy(criteria).First() pode ser otimizado para Min(criteria)

  • É positivo que a biblioteca reconheça e corrija padrões ineficientes