Cómo usar excepciones en C#

Una excepción en C# es un objeto que representa un error que ocurre durante la ejecución de un programa. Cuando ocurre una excepción, el flujo normal del programa se interrumpe. Entonces se busca un bloque llamado try-catch que capture (y gestione) el error.

Si no hay un bloque try-catch que capture la excepción, esta va “subiendo”. Si nadie la gestiona, la excepción llegará a la función principal (lo normal es que el programa termine abruptamente).

Lanzar una excepción

En C#, podemos lanzar una excepción nosotros mismos utilizando la palabra clave throw. Al lanzar una excepción, estamos indicando que ha ocurrido un error y queremos notificarlo al programa.

throw new Exception("Ocurrió un error");

En el ejemplo anterior, estamos lanzando una excepción de tipo Exception con un mensaje de error específico. Este mensaje se puede utilizar posteriormente para identificar el error y tomar las medidas necesarias.

Excepciones predefinidas

En C#, existen diferentes tipos de excepciones que podemos capturar utilizando el bloque try-catch. Algunos ejemplos de excepciones comunes son:

NullReferenceException: Ocurre cuando intentas acceder a un miembro de un objeto que es null. Por ejemplo:

string nombre = null;
int longitud = nombre.Length;  // Lanzará NullReferenceException

IndexOutOfRangeException: Se lanza cuando intentas acceder a un índice que está fuera del rango de una colección o un array. Por ejemplo:

int[] numeros = {1, 2, 3};
int valor = numeros[5];  // Lanzará IndexOutOfRangeException

DivideByZeroException: Se produce cuando intentas dividir un número por cero. Por ejemplo:

int divisor = 0;
int resultado = 10 / divisor;  // Lanzará DivideByZeroException

FileNotFoundException: Se lanza cuando intentas acceder a un archivo que no existe. Por ejemplo:

using (StreamReader reader = new StreamReader("archivo_que_no_existe.txt"))
{
    string contenido = reader.ReadToEnd();  // Lanzará FileNotFoundException
}

ArgumentException: Se produce cuando un argumento pasado a un método es inválido. Por ejemplo:

void ConfigurarEdad(int edad)
{
    if (edad < 0) throw new ArgumentException("La edad no puede ser negativa.");
}
ConfigurarEdad(-5);  // Lanzará ArgumentException

InvalidOperationException: Ocurre cuando el estado del objeto no es válido para la operación que se está realizando. Por ejemplo:

List<int> lista = new List<int>();
int valor = lista[0];  // Lanzará InvalidOperationException si la lista está vacía

FormatException: Se produce cuando una operación de conversión de tipo falla debido a un formato incorrecto. Por ejemplo:

string numero = "abc";
int valor = int.Parse(numero);  // Lanzará FormatException

IOException: Se lanza en situaciones de error de entrada/salida, como problemas al leer o escribir en un archivo. Por ejemplo:

using (StreamWriter writer = new StreamWriter("archivo.txt"))
{
    writer.WriteLine("Hola Mundo");  // Lanzará IOException si hay un problema con el archivo
}

TimeoutException: Ocurre cuando una operación supera el tiempo de espera permitido. Por ejemplo, en operaciones de red o base de datos:

// Ejemplo simplificado
var client = new HttpClient();
client.Timeout = TimeSpan.FromSeconds(1);  // Timeout corto para el ejemplo
var response = await client.GetAsync("https://www.ejemplo.com");  // Lanzará TimeoutException si el tiempo de espera se excede

Creando tus propias excepciones en .NET

Además de utilizar las excepciones predefinidas en .NET es posible crear nuestras propias excepciones personalizadas. Esto nos permite ser más específicos a la hora de gestionar los errores en tus aplicaciones.

Para crear nuestras propias excepciones, simplemente tenemos que crear una clase que herede de la clase base Exception (luego puedes agregar cualquier propiedad o método que necesites para proporcionar información adicional sobre el error).

Aquí hay un ejemplo de una clase de excepción personalizada:

public class MiExcepcion : Exception
{
    public MiExcepcion(string mensaje) : base(mensaje) { }
    public MiExcepcion(string mensaje, Exception innerException) : base(mensaje, innerException) { }
}

En el código anterior,

• La clase MiExcepcion hereda de la clase Exception
• Agrega dos constructores para proporcionar un mensaje de error y la posibilidad de incluir una excepción interna.

Una vez que tienes tu clase de excepción personalizada, puedes utilizarla en tu código de la misma manera que utilizarías cualquier otra excepción de .NET. Por ejemplo:

try
{
    // Código que puede generar una excepción
    throw new MiExcepcion("Error en mi aplicación");
}
catch (MiExcepcion ex)
{
    // Manejo de la excepción personalizada
}