Errores y excepciones

Última actualización: 6 de noviembre de 2026 4 min de lectura Editar en GitHub

Los errores se informan lanzando una excepción: un objeto de una clase derivada de System.Exception. El try más cercano que tenga un catch compatible la maneja.

AntrilRun

import System;

into namespace Bank
{
	public exception InsufficientFunds
	{
		public:
			i32 Missing;

			new(i32 missing) : base("insufficient funds")
			{
				Missing = missing;
			}
	}

	Withdraw(i32 balance, i32 amount) : i32
	{
		if (amount > balance)
			throw new InsufficientFundsException(amount - balance);
		return balance - amount;
	}

	Main()
	{
		try
		{
			Console.WriteLine(Withdraw(30, 10));
			Console.WriteLine(Withdraw(10, 25));
		}
		catch (InsufficientFundsException e)
		{
			Console.WriteLine(e.Message + ": " + e.Missing + " missing");
		}
		finally
		{
			Console.WriteLine("done");
		}
	}
}

Terminal

$ larva run
20
insufficient funds: 15 missing
done

Declarar excepciones

exception Name { … } declara la clase NameException, derivada de System.Exception. El sufijo se agrega solo, y la lanzas y la atrapas por su nombre completo. Su base puede ser otra excepción, escrita sin el sufijo:

Antril

public exception NotFound
{
	public:
		new(str message) : base(message) { }
}

public exception FileNotFound : NotFound
{
	public:
		new(str path) : base("no file " + path) { }
}

throw new FileNotFoundException("notes.txt");

System.Exception tiene un Message. Una clase también puede derivar directamente de Exception.

Lanzar

throw value; lanza un objeto de excepción. Dentro de un catch, throw; vuelve a lanzar la misma excepción.

Una función genérica puede lanzar un parámetro de tipo restringido con T : exception.

Atrapar

AntrilRun

import System;

Main()
{
	try
	{
		List<i32> empty = new List<i32>();
		empty.At(3);
	}
	catch (IndexError e)
	{
		Console.WriteLine("IndexError: " + e.Message);
	}

	try
	{
		Int32.Parse("x1");
	}
	catch
	{
		Console.WriteLine("something failed");
	}

	try
	{
		try
		{
			throw new InvalidOperationError("inner");
		}
		catch (Exception e)
		{
			Console.WriteLine("logging " + e.Message);
			throw;
		}
	}
	catch (InvalidOperationError e)
	{
		Console.WriteLine("handled " + e.Message);
	}
}

Terminal

$ larva run
IndexError: the index is outside the collection
something failed
logging inner
handled inner

catch (T e) maneja las excepciones de tipo T y de los tipos derivados de él. El nombre se puede omitir: catch (KeyNotFoundError).
catch solo, sin tipo, maneja cualquier excepción.
Las cláusulas catch se prueban en orden.
finally se ejecuta cuando termina el try, sin importar cómo termine: de forma normal, por una excepción, o por return, break o continue.

Una excepción lanzada dentro de una función async viaja en su tarea, y await la vuelve a lanzar (consulta Código asíncrono y reactivo).

Excepciones de la biblioteca estándar

Excepción	Se lanza cuando
`ArgumentError`, `ArgumentOutOfRangeError`	Un argumento no es uno que el método acepte.
`IndexError`	Un índice está fuera de una colección.
`KeyNotFoundError`	Un diccionario no tiene la clave.
`InvalidOperationError`	El objeto no está en un estado que permita la operación, como `Dequeue` o `Peek` sobre una cola vacía.
`OverflowError`	Un resultado no cabe en su tipo.
`FormatError`	Un texto no se puede interpretar (`Int32.Parse("x")`).
`IOError`	Falla una operación sobre un archivo, una carpeta o un flujo (`System.IO`).

Excepciones no atrapadas

Una excepción que ningún catch maneja termina el programa con código de salida 1:

Terminal

$ larva run
larva: unhandled exception (type id 461533486)

Siguiente: Memoria.