Principais erros de desenvolvedores C# iniciantes e como evitá-los

Introdução: Por que Erros São Normais

A jornada de todo desenvolvedor começa com erros. C# (.NET) é uma linguagem poderosa e fortemente tipada que perdoa menos que linguagens dinâmicas, mas em troca oferece confiabilidade e desempenho. Neste artigo, vamos detalhar as 4 armadilhas mais comuns que iniciantes enfrentam e mostrar como evitá-las. Este artigo será útil tanto para quem está começando a aprender C# quanto para quem deseja revisar seus conhecimentos.

1. Ignorando null e NullReferenceException

O erro mais popular em C# é NullReferenceException. Ele ocorre quando você tenta acessar um membro de um objeto que é null.

Exemplo do Problema

string text = null;int length = text.Length; // Erro! NullReferenceException

Iniciantes frequentemente esquecem de verificar valores retornados por métodos, ou confiam na suposição de que um objeto definitivamente existe.

Como Fazer Corretamente

• Sempre verifique objetos quanto a null antes de usá-los.
• Use os operadores ?. (null-conditional) e ?? (null-coalescing).

string text = GetText(); // pode retornar nullint? length = text?.Length; // se text == null, length será nullint safeLength = text?.Length ?? 0; // se null, então 0Console.WriteLine(safeLength);

Também em C# 8.0+, surgiram os tipos de referência anuláveis, que são habilitados via #nullable enable. Eles forçam você a especificar explicitamente se uma variável pode ser null, e alertam sobre problemas potenciais em tempo de compilação.

2. Uso Incorreto de var e Perda de Legibilidade

A palavra-chave var permite que o compilador determine o tipo de uma variável por conta própria. Isso é conveniente, mas iniciantes frequentemente abusam dela, tornando o código ilegível.

Exemplo de Código Ruim

var data = GetData();var result = Process(data);var output = Transform(result); // Quais tipos? Não está claro.

Em um mês, você (ou seu colega) não conseguirá entender rapidamente qual é o tipo de data sem olhar a definição do método.

Quando Usar var

• Quando o tipo é óbvio pelo lado direito (ex.: var list = new List<int>();)
• Ao trabalhar com tipos anônimos e consultas LINQ.

// Bom: tipo é óbviovar numbers = new List<int> { 1, 2, 3 };

// Bom: tipo anônimovar person = new { Name = "João", Age = 30 };

// Ruim: tipo não está clarovar config = LoadConfiguration(); // Melhor: Configuration config = LoadConfiguration();

Regra de ouro: use var apenas quando melhorar a legibilidade, não quando reduzi-la.

3. Engolindo Exceções e Blocos catch Vazios

Muitos iniciantes, ao encontrarem exceções, escrevem um catch vazio ou simplesmente exibem uma mensagem sem analisar o erro. Isso torna o programa instável e dificulta a depuração.

Exemplo de um Antipadrão

try{    int.Parse("não é um número");}catch (Exception){    // Não faz nada — o erro é "engolido"}

A aplicação continuará executando, mas em um estado incorreto. O usuário não saberá sobre o problema, e os dados podem ser corrompidos.

Como Lidar com Exceções Corretamente

• Não capture Exception genérica a menos que planeje lidar com todos os tipos de erros.
• Capture apenas as exceções que você pode tratar (ex.: FormatException, FileNotFoundException).
• Use finally para liberar recursos (arquivos, conexões).
• Registre erros em log.

try{    int number = int.Parse(userInput);}catch (FormatException ex){    // Registrar em log e informar o usuário