C# – Cinco erros de desenvolvedores ao trabalhar com listas

Neste artigo vou apresentar cinco erros que geralmente são cometidos por devs C#↳C#68 conteúdosNovidades do C# 8.0: Default Interface MembersDev (Back & Front) · jun 2019C# 8.0 – Conheça suas novas funcionalidadesDev (Back & Front) · mai 2019Novidades do C# 8.0: Switch ExpressionsDev (Back & Front) · mar 2019Ver tudo em Dev (Back & Front) → ao tratar com listas.

No C# as listas são uma estrutura de dados fundamental que todo desenvolvedor utiliza. Elas oferecem uma forma flexível de armazenar e manipular coleções de dados, tornando-as ideais para diversos cenários de programação. No entanto, apesar de sua simplicidade, as listas podem ser a fonte de bugs sutis e problemas de desempenho quando não são usadas corretamente. 

Neste artigo, vou explorar os 5 erros comuns que os desenvolvedores cometem ao trabalhar com listas no C# e como evitá-los, garantindo que seu código seja eficiente e robusto.

Erro 1- Iteração ineficiente em listas grandes

Iterar sobre listas grandes usando loops for ou foreach tradicionais pode ser ineficiente, especialmente quando a lista contém milhares ou até milhões de itens. Desenvolvedores frequentemente ignoram formas melhores de lidar com tais iterações.

Por que é um problema:

Usar loops simples para listas grandes pode levar a um desempenho mais lento, pois cada iteração adiciona sobrecarga. Isso pode se tornar um gargalo em aplicações que dependem fortemente do processamento de grandes coleções, como análise de dados↳Engenharia de dados43 conteúdosResolvendo desafios de Big Data com Ciência de Dados na UberData · abr 2019Análise de dados com Python e tabelas dinâmicas com PandasData · mai 2019Ferramentas para análise de dados são cada vez mais fundamentais para auxiliar pessoas desenvolvedorasData · jun 2024Ver tudo em Data → ou aplicações em tempo real.

Como evitar:

Usando a LINQ: O C# oferece métodos LINQ poderosos como Select, Where, Any e All, que são otimizados para trabalhar com coleções. Por exemplo:

var listafiltradas = minhaLista.Where(item => item.IsActive).ToList();

Iteração Paralela: Se a lista for extremamente grande e as operações em cada item forem independentes, você pode usar Parallel.ForEach para paralelizar o processamento:

Parallel.ForEach(minhaListaGrande, item => {
             ProcessarItem(item);
});

Ao escolher a técnica de iteração correta, você pode melhorar significativamente o desempenho da sua aplicação.

Erro 2: Modificar listas enquanto itera

Um erro comum é tentar modificar uma lista (como adicionar ou remover itens) enquanto itera sobre ela usando um loop foreach. Isso pode levar a exceções de tempo de execução como InvalidOperationException.

Por que é um problema:

Modificar uma lista durante a iteração pode interromper a enumeração subjacente, causando comportamento inesperado ou exceções. Por exemplo, tentar remover itens de uma lista dentro de um loop foreach resulta em um erro.

Como evitar:

Use uma Lista Secundária: Quando você precisar remover itens de uma lista durante a iteração, armazene os itens a serem removidos em uma lista secundária e, em seguida, remova-os após o loop:

var itemsARemover = new List<MeuTipo>();

foreach (var item in minhaLista)
{
    if (ShouldRemove(item))
        itemsARemover.Add(item);
}

foreach (var item in itemsARemover)
{
    minhaLista.Remove(item);
}

Use LINQ para Filtragem: Alternativamente, você pode usar LINQ para criar uma nova lista filtrada:

minhaLista = minhaLista.Where(item => !ShouldRemove(item)).ToList();

Esses métodos evitam erros e tornam seu código mais limpo.

Erro #3: Não Compreender a Capacidade da Lista

A List<T> em C# tem uma propriedade Capacity (Capacidade), que é o número de elementos que a lista pode conter antes de precisar redimensionar. Desenvolvedores frequentemente ignoram a configuração da capacidade, levando a múltiplas operações de redimensionamento à medida que os itens são adicionados.

Por que é um problema:

Quando uma lista excede sua capacidade atual, ela automaticamente aumenta sua capacidade criando um novo array maior e copiando os elementos para ele. Esse redimensionamento pode impactar o desempenho se for feito frequentemente com listas grandes.

Como evitar:

Defina a Capacidade Inicial: Se você souber o número aproximado de itens que serão adicionados à lista, defina a capacidade inicial para evitar múltiplos redimensionamentos:

var minhaLista = new List<int>(1000);   // Define a capacidade inicial para 1000.

Use EnsureCapacity: Se o tamanho da lista for dinâmico, mas você quiser evitar o redimensionamento até um certo número, use EnsureCapacity:

minhaLista.EnsureCapacity(5000);

Ao gerenciar a capacidade da lista, você pode tornar suas operações com listas mais eficientes.

Erro #4: Usar List em Vez de ReadOnlyCollection

Desenvolvedores frequentemente expõem List<T> diretamente de suas classes quando não pretendem que a lista seja modificada por código externo. Isso pode levar a alterações não intencionais na lista.

Por que é um problema:

Expor List<T> diretamente possibilita que qualquer consumidor de sua classe adicione, remova ou modifique elementos, o que pode ser contra as intenções de design. Isso pode causar problemas de integridade de dados.

Como evitar:

Use ReadOnlyCollection: Embrulhe sua lista em um ReadOnlyCollection<T> antes de expô-la:

private readonly List<string> _nomes = new List<string>();
 public ReadOnlyCollection<string> Nomes => _nomes.AsReadOnly();

Use Coleções Imutáveis: Em cenários onde você deseja imutabilidade completa, use o recurso ImmutableList<T> do System.Collections.Immutable:

  var listaImutavel = ImmutableList.CreateRange(minhaLista);

Essas opções garantem que sua lista seja modificada apenas internamente, mantendo uma melhor encapsulamento.

Erro #5: Técnicas de Classificação Ineficientes

Classificar listas é uma tarefa comum, mas a lógica de classificação personalizada pode ser menos eficiente em comparação com métodos incorporados como List<T>.Sort().

Por que é um problema:

Escrever lógica de classificação personalizada pode ser propenso a erros e menos otimizado do que os métodos nativos fornecidos pelo .NET 8, levando a um desempenho de classificação mais lento.

Como evitar:

Use List<T>.Sort() para classificação no Local: Este método é altamente otimizado e deve ser sua primeira opção para classificar uma lista no local:

 minhaLista.Sort((a, b) => a.Property.CompareTo(b.Property));

Use LINQ OrderBy() para Criar Cópias Classificadas: Se você quiser preservar a lista original enquanto cria uma versão classificada:

var listaOrdenada = minhaLista.OrderBy(item => item.Property).ToList();

Escolher o método de classificação certo ajuda a manter seu código conciso e eficiente.

Trabalhar com listas no C# é crucial para muitas aplicações, mas mesmo desenvolvedores experientes podem cair em armadilhas comuns. Ao entender esses 5 erros e como evitá-los, você pode escrever código mais eficiente, de fácil manutenção e menos propenso a erros.

Aplique essas dicas em seus projetos e você verá melhorias tanto no desempenho quanto na confiabilidade