C# Academy · Lección

Excepciones personalizadas y diseño de errores

C cree excepciones personalizadas pequeñas, elija los tipos integrados adecuados (ArgumentException, InvalidOperationException) y añada contexto con InnerException.

Excepciones personalizadas y diseño de errores es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 2 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 3 lecciones en total.

Propósito y objetivos

Objetivo: Hacer que los errores sean claros y se puedan capturar.

Use un tipo específico para cada fallo concreto
Añada un mensaje claro y InnerException para aportar contexto
Prefiera los tipos integrados cuando sean adecuados

Tipo de excepción personalizado

Herede de Exception, termine el nombre en Exception y añada los constructores estándar. Incluya datos pequeños y útiles.

using System;

// Custom, specific to our domain
public sealed class ConfigNotFoundException : Exception
{
  public string Key { get; private set; }

  public ConfigNotFoundException(string key)
    : base("Config key not found: " + key)
  {
    Key = key;
  }

  public ConfigNotFoundException(string key, Exception inner)
    : base("Config key not found: " + key, inner)
  {
    Key = key;
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    try
    {
      throw new ConfigNotFoundException("ApiUrl");
    }
    catch (ConfigNotFoundException ex)
    {
      Console.WriteLine(ex.Message);
    }
  }
}

InnerException para aportar contexto

Envuelva las excepciones de nivel inferior con una excepción de dominio y establezca InnerException para conservar la causa raíz.

using System;
using System.IO;

public sealed class ConfigNotFoundException : Exception
{
  public string Key { get; private set; }
  public ConfigNotFoundException(string key, Exception inner)
    : base("Config key not found: " + key, inner) { Key = key; }
}

public static class Config
{
  public static string Load(string path, string key)
  {
    try
    {
      string[] lines = File.ReadAllLines(path); // may throw
      for (int i = 0; i < lines.Length; i++)
      {
        int idx = lines[i].IndexOf("=");
        if (idx > 0 && lines[i].Substring(0, idx) == key)
          return lines[i].Substring(idx + 1);
      }
      throw new ConfigNotFoundException(key, null);
    }
    catch (IOException io)
    {
      // Wrap low-level error with domain meaning
      throw new ConfigNotFoundException(key, io);
    }
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    try
    {
      Console.WriteLine(Config.Load("missing.cfg", "ApiUrl"));
    }
    catch (ConfigNotFoundException ex)
    {
      Console.WriteLine("Top: " + ex.Message);
      if (ex.InnerException != null)
        Console.WriteLine("Inner: " + ex.InnerException.GetType().Name);
    }
  }
}

Elija primero los tipos integrados

Use las excepciones integradas para problemas habituales: ArgumentNullException, ArgumentOutOfRangeException, FormatException, InvalidOperationException, etc.

using System;

public static class MathUtil
{
  public static int Divide(int a, int b)
  {
    if (b == 0) throw new DivideByZeroException();
    return a / b;
  }

  public static int ParsePositive(string text)
  {
    if (text == null) throw new ArgumentNullException("text");
    int value = int.Parse(text); // may throw FormatException
    if (value <= 0) throw new ArgumentOutOfRangeException("text", "must be > 0");
    return value;
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    try { Console.WriteLine(MathUtil.ParsePositive("-1")); }
    catch (ArgumentOutOfRangeException ex) { Console.WriteLine("Range: " + ex.ParamName); }
  }
}

Excepciones frente a validaciones

Use excepciones para situaciones excepcionales. Para fallos esperados, prefiera validaciones TryX o códigos de retorno.

using System;

public static class Parser
{
  // BAD: using exceptions for expected cases
  public static int ParseOrThrow(string s)
  {
    return int.Parse(s); // will throw often for user input
  }

  // GOOD: guard-check pattern for expected failure
  public static bool TryParsePositive(string s, out int value)
  {
    value = 0;
    int tmp;
    if (!int.TryParse(s, out tmp)) return false;
    if (tmp <= 0) return false;
    value = tmp;
    return true;
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    int v;
    if (Parser.TryParsePositive("12", out v))
      Console.WriteLine("OK " + v);
    else
      Console.WriteLine("Invalid");
  }
}

Lista de comprobación para diseñar errores

Lista de comprobación:

Elija un tipo integrado cuando sea posible.
De lo contrario, cree una pequeña CustomException con constructores estándar.
Asocie InnerException para conservar la causa raíz.
Use excepciones para casos inesperados y TryX para fallos esperados.

Diseño de excepciones personalizadas

Comprobación rápida: ¿Cuál es un diseño recomendado para un tipo de excepción personalizado en C#?

Repaso

Repaso: Prefiera las excepciones integradas; de lo contrario, defina un tipo personalizado pequeño con constructores estándar y use InnerException para añadir contexto sin perder la causa.

Preguntas frecuentes

¿La lección «Excepciones personalizadas y diseño de errores» es gratis?

Sí — el texto completo de «Excepciones personalizadas y diseño de errores» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 3 lecciones en total.

¿Qué aprenderé en «Excepciones personalizadas y diseño de errores»?

C cree excepciones personalizadas pequeñas, elija los tipos integrados adecuados (ArgumentException, InvalidOperationException) y añada contexto con InnerException. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 3.

¿Cuánto tiempo toma la lección «Excepciones personalizadas y diseño de errores»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

try/catch/finally, throw new frente a rethrow
Excepciones personalizadas y diseño de errores
IDisposable y la instrucción using

← Volver a C# Academy