CSharp
Tutorial CSharp: Excepciones
CSharp excepciones: manejo y prevención. Aprende a manejar y prevenir excepciones en CSharp con ejemplos prácticos y detallados.
Aprende CSharp GRATIS y certifícateUna excepción es una respuesta a una condición excepcional que requiere acción inmediata. Es la forma que tiene un programa de indicar que se ha producido un error durante la ejecución.
El manejo de excepciones es un mecanismo que permite separar el código que resuelve problemas y errores del resto del programa. En lugar de tener código de comprobación de errores esparcido por todas partes, se agrupan los errores en bloques y se gestiona de forma organizada.
En C#, la clase base de todas las excepciones es la clase Exception
. Esta clase define varias propiedades y métodos que son comunes a todas las excepciones.
Bloques try
y catch
La gestión de errores se realiza principalmente mediante los bloques try
y catch
. El bloque try
contendrá el código que es susceptible de lanzar un error, y el bloque catch
indicará que hacer si se lanza una excepción.
Un ejemplo sencillo en el que se lanza y se captura una excepción sería:
try
{
int x = 0;
int y = 5;
int z = y / x;
}
catch (DivideByZeroException ex)
{
Console.WriteLine("Se ha intentado dividir por cero: " + ex.Message);
}
En este código, se ha colocado el código que puede lanzar una excepción dentro de un bloque try
. Si ocurre una excepción en este bloque, el control se transfiere al bloque catch
correspondiente.
En este caso, se intenta dividir por cero, lo que lanza una DivideByZeroException
. Esta excepción se captura en el bloque catch
y se muestra un mensaje de error.
Tipos de Excepciones
En C#, hay una variedad de clases de excepciones que se derivan de la clase Exception
. Algunas de las más comunes son:
DivideByZeroException
: lanzada cuando se intenta dividir por cero.ArgumentNullException
: lanzada cuando un argumento null se pasa a un método que no acepta null como argumento válido.ArgumentOutOfRangeException
: lanzada cuando el valor de un argumento está fuera del rango de valores permitidos.InvalidOperationException
: lanzada cuando se intenta realizar una operación que no es válida en el estado actual del objeto.
Por ejemplo, para lanzar y capturar una ArgumentOutOfRangeException
:
try
{
List<int> numeros = new List<int> {1, 2, 3};
Console.WriteLine(numeros[3]);
}
catch (ArgumentOutOfRangeException ex)
{
Console.WriteLine("El índice está fuera del rango de la lista: " + ex.Message);
}
En este caso, se intenta acceder al cuarto elemento de una lista que sólo tiene tres elementos. Esto lanza una ArgumentOutOfRangeException
, que puede capturarse para mostrar un mensaje de error.
Uso de múltiples bloques catch
En C#, es posible usar varios bloques catch
uno tras otro para capturar diferentes tipos de excepciones. Esto es útil cuando el bloque de código dentro del try
puede lanzar más de un tipo de excepción y deseas manejar cada tipo de excepción de manera diferente.
Por ejemplo:
try
{
// Código que puede lanzar diferentes tipos de excepciones
}
catch (DivideByZeroException ex)
{
Console.WriteLine("Se ha intentado dividir por cero: " + ex.Message);
}
catch (ArgumentOutOfRangeException ex)
{
Console.WriteLine("El índice está fuera del rango de la lista: " + ex.Message);
}
catch (Exception ex)
{
Console.WriteLine("Ocurrió una excepción: " + ex.Message);
}
En este caso, si el código dentro del bloque try
lanza una DivideByZeroException
o una ArgumentOutOfRangeException
, el control se transfiere al bloque catch
correspondiente.
El último bloque catch
en el ejemplo anterior captura cualquier excepción que herede de la clase Exception
. Esto incluye todas las excepciones en C#, ya que todas las excepciones en C# heredan de la clase Exception
. Este bloque catch
captura cualquier excepción que no haya sido capturada por los bloques catch
anteriores.
Es importante destacar que el orden de los bloques catch
importa. El compilador evalúa los bloques catch
de arriba a abajo, y sólo la primera coincidencia se ejecuta. Por lo tanto, el bloque catch
más general (en este caso, el que captura la clase base Exception
) debe ir siempre al final. De lo contrario, las excepciones más específicas nunca serían capturadas por sus bloques catch
correspondientes, ya que la excepción general las capturaría primero.
Creación y lanzamiento de excepciones personalizadas
Es posible que sea necesario crear tus propias excepciones para manejar situaciones específicas en el código. Para hacer esto, puede crearse una clase que se derive de Exception
.
public class MiExcepcion : Exception
{
public MiExcepcion(string message) : base(message)
{
}
}
A continuación, puede lanzarse esta excepción personalizada en el código usando la palabra clave throw
, como con cualquier otra excepción.
try
{
throw new MiExcepcion("Ha ocurrido un error personalizado");
}
catch (MiExcepcion ex)
{
Console.WriteLine(ex.Message);
}
En este ejemplo, se crea una nueva excepción llamada MiExcepcion
y se lanza con un mensaje personalizado. Luego, se captura la excepción en un bloque catch
y se muestra el mensaje.
Bloques finally
Además de try
y catch
, también puede usarse un bloque finally
en el manejo de excepciones. El código dentro de un bloque finally
se ejecutará siempre, independientemente de si se lanza una excepción o no.
try
{
int x = 0;
int y = 5;
int z = y / x;
}
catch (DivideByZeroException ex)
{
Console.WriteLine("Se ha intentado dividir por cero: " + ex.Message);
}
finally
{
Console.WriteLine("Este mensaje se muestra siempre, ocurra o no la excepción.");
}
En este código, después de que el bloque try
o catch
se ejecutan, se ejecuta el bloque finally
y se muestra el mensaje en la consola. Esto es útil para código que debe ejecutarse independientemente de si se produce un error, como la limpieza de recursos.
En resumen, el manejo de excepciones en C# es un mecanismo poderoso para controlar los errores durante la ejecución de un programa y asegurarse de que los recursos se limpien adecuadamente.
Ejercicios de esta lección Excepciones
Evalúa tus conocimientos de esta lección Excepciones con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.
Todas las lecciones de CSharp
Accede a todas las lecciones de CSharp y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.
Introducción A C#
Sintaxis
Creación De Proyecto C#
Sintaxis
Variables Y Constantes
Sintaxis
Tipos De Datos
Sintaxis
Operadores
Sintaxis
Control De Flujo
Sintaxis
Funciones
Sintaxis
Clases Y Encapsulación
Programación Orientada A Objetos
Objetos
Programación Orientada A Objetos
Constructores Y Destructores
Programación Orientada A Objetos
Herencia
Programación Orientada A Objetos
Polimorfismo
Programación Orientada A Objetos
Excepciones
Excepciones
Arrays Y Listas
Colecciones Y Linq
Diccionarios
Colecciones Y Linq
Conjuntos, Colas Y Pilas
Colecciones Y Linq
Uso De Consultas Linq
Colecciones Y Linq
Delegados
Programación Asíncrona
Eventos
Programación Asíncrona
Lambdas
Programación Asíncrona
Uso De Async Y Await
Programación Asíncrona
Tareas
Programación Asíncrona
En esta lección
Objetivos de aprendizaje de esta lección
- Comprender el concepto de excepciones y su importancia en el manejo de errores en C#.
- Aprender a utilizar los bloques
try
ycatch
para manejar excepciones y evitar que el programa se bloquee. - Conocer los diferentes tipos de excepciones comunes en C# y cómo capturarlas de manera específica.
- Entender el uso de bloques
finally
para garantizar que cierto código se ejecute independientemente de si se lanza una excepción o no. - Familiarizarse con la creación y lanzamiento de excepciones personalizadas para manejar situaciones específicas en el código.