C# trata erros com exceções capturadas via try/catch/finally. O tratamento adequado de exceções significa capturar tipos específicos de exceção, limpar recursos (geralmente com using), criar exceções personalizadas significativas e não suprimir erros silenciosamente.
try
{
var data = RiskyOperation();
}
catch (FileNotFoundException ex) // catch SPECIFIC types (most specific first)
{
Console.WriteLine($"File missing: {ex.Message}");
}
catch (IOException ex)
{
Log(ex);
throw; // re-throw, PRESERVING the stack trace (not `throw ex`)
}
catch (Exception ex) // catch-all (last) — base of all exceptions
{
Log(ex);
}
finally
{
Cleanup(); // ALWAYS runs (success, exception, or return)
}
Capture tipos de exceção específicos primeiro, use Exception como uma captura final abrangente, e finally para limpeza que deve sempre ser executada. Importante: use throw; (não throw ex;) para relançar — isso preserva o rastreamento de pilha original.
if (amount < 0)
throw new ArgumentException("Amount must be positive", nameof(amount));
// a custom exception for your domain
public class InsufficientFundsException : Exception
{
public InsufficientFundsException(string message) : base(message) { }
}
throw new InsufficientFundsException("Balance too low");
// `using` guarantees Dispose() is called (close files/connections) even on exception
using (var file = new StreamReader("data.txt"))
{
var content = file.ReadToEnd();
} // file.Dispose() called automatically here
using var conn = new SqlConnection(...); // C# 8 simplified form
A instrução using garante que recursos IDisposable (arquivos, conexões) sejam propriamente descartados — a forma preferida de lidar com limpeza de recursos, mais confiável que finally manual.
catch (Exception ex) when (ex.Message.Contains("timeout")) // exception filter (when)
{ ... }
✓ Catch SPECIFIC exceptions, not just Exception
✓ Use `using` for IDisposable resources (reliable cleanup)
✓ Don't swallow exceptions silently (empty catch) — log or re-throw
✓ Use `throw;` (not `throw ex;`) to preserve the stack trace
✓ Create meaningful custom exceptions; don't use exceptions for normal control flow
O tratamento adequado de exceções é essencial para construir aplicações C# robustas e confiáveis, portanto compreendê-lo bem é importante.
A estrutura try/catch/finally, capturando tipos de exceção específicos (para tratamento direcionado) com Exception como uma captura final abrangente, e finally para limpeza garantida são fundamentais.
Várias melhores práticas específicas do C# são particularmente importantes: usar throw; em vez de throw ex; ao relançar (um detalhe sutil mas crucial — throw ex; reseta o rastreamento de pilha, perdendo informações valiosas de depuração), usar a instrução using para recursos IDisposable (a forma preferida e confiável de garantir que arquivos, conexões e outros recursos sejam propriamente limpos mesmo quando exceções ocorrem — mais robusto que blocos finally manuais, e central ao modelo de gerenciamento de recursos do C#), e não suprimir exceções silenciosamente.
Compreender o tratamento de exceções — a estrutura, capturas específicas, exceções personalizadas, o relançamento que preserva rastreamento de pilha, e especialmente using para limpeza de recursos — é importante para escrever C# confiável que trata erros graciosamente e gerencia recursos corretamente.
Como exceções não tratadas e vazamentos de recursos causam problemas reais de confiabilidade, e como C# tem idiomas específicos (o padrão using, preservação de throw;) que distinguem código robusto de código frágil, dominar o tratamento de exceções é conhecimento importante e frequentemente aplicado para desenvolvimento profissional em C#.