C# maneja errores con excepciones capturadas mediante try/catch/finally. El manejo adecuado de excepciones significa capturar tipos de excepciones específicos, limpiar recursos (a menudo con using), crear excepciones personalizadas significativas y no silenciar errores.
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)
}
Captura primero tipos de excepciones específicas, usa Exception como captura final, y finally para limpieza que debe ejecutarse siempre. Importante: usa throw; (no throw ex;) para relanzar — preserva el stack trace 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
La declaración using asegura que los recursos IDisposable (archivos, conexiones) se eliminen correctamente — la forma preferida de manejar la limpieza de recursos, más confiable 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
El manejo adecuado de excepciones es esencial para construir aplicaciones C# robustas y confiables, por lo que comprenderlo a fondo es importante.
La estructura try/catch/finally, capturar tipos de excepciones específicas (para manejo dirigido) con Exception como captura final, y finally para limpieza garantizada son fundamentales.
Varias mejores prácticas específicas de C# son particularmente importantes: usar throw; en lugar de throw ex; al relanzar (un detalle sutil pero crucial — throw ex; reinicia el stack trace, perdiendo información valiosa de depuración), usar la declaración using para recursos IDisposable (la forma preferida y confiable de asegurar que archivos, conexiones y otros recursos se limpien correctamente incluso cuando ocurren excepciones — más robusto que bloques finally manuales, y central en el modelo de gestión de recursos de C#), y no silenciar excepciones.
Comprender el manejo de excepciones — la estructura, capturas específicas, excepciones personalizadas, el relanzamiento preservador del stack trace, y especialmente using para limpieza de recursos — es importante para escribir C# confiable que maneje errores elegantemente y gestione recursos correctamente.
Ya que las excepciones no controladas y las fugas de recursos causan problemas reales de confiabilidad, y ya que C# tiene idiomas específicos (el patrón using, preservación de throw;) que distinguen código robusto de código frágil, dominar el manejo de excepciones es conocimiento importante y aplicado frecuentemente para el desarrollo profesional de C#.