Manejo de Excepciones en C#: Try, Catch y Finally
Clase 33 de 35 • Curso de C# con .Net Core 2.1
Contenido del curso
- 2

Reutilización de Código en C y Programación Orientada a Objetos
10:30 - 3

Herencia y Polimorfismo en Programación Orientada a Objetos
11:42 - 4

Polimorfismo en Programación Orientada a Objetos
13:17 - 5

Polimorfismo en Programación: Uso y Errores Comunes en Visual Studio
07:09 - 6

Validación y Conversión de Tipos en C# para Gestión de Objetos Escuela
12:44 - 7

Sobrescritura de Método ToString para Depuración Eficiente
08:15
- 11

Manejo Avanzado de Métodos y Parámetros en Programación
15:43 - 12

Manejo de Parámetros de Salida en Visual Studio Code
04:38 - 13

Sobrecarga de Métodos para Parámetros de Salida Opcionales
05:51 - 14

Optimización de Listas: Buenas Prácticas en C#
04:16 - 15

Uso de Diccionarios en C# para Gestión de Datos en Aplicaciones
11:15 - 16

Creación y Manejo de Diccionarios en C# para Aplicaciones Escolares
10:48 - 17

Uso de Constantes y Enumeraciones para Optimizar Diccionarios en C#
11:34 - 18

Creación y Manejo de Diccionarios en C# para Gestión Escolar
13:47 - 19

Impresión de Diccionarios en Visual Studio con C#
09:37 - 20

Filtrado y Personalización de Impresión en C#
11:47 - 21

Uso del operador switch en Visual Studio para optimizar código
14:30 - 22

Optimización de Algoritmos y Eventos en C#
12:52 - 23

Diccionarios y Refactoring en Programación Básica
02:13
- 24

Consultas y Reportes en Proyectos C# Básicos
11:42 - 25

Generación segura de reportes en sistemas de información
10:21 - 26

Generación de Reportes en Visual Studio Code
11:48 - 27

Creación de Reporte de Evaluaciones por Asignatura en Programación OO
08:32 - 28

Creación de Reportes Complejos con LinQ en Visual Studio
10:52 - 29

Cálculo del Promedio de Notas Agrupadas por Alumno y Asignatura
10:47 - 30

Creación de Tipos de Datos Personalizados en Programación Avanzada
12:05 - 31

Generación de Reportes con LINQ en C#
02:09
¿Cómo manejar la sentencia "finally" en excepciones?
En el manejo de excepciones en programación, la sentencia "finally" es fundamental pero frecuentemente subestimada. Resulta indispensable en situaciones donde, independientemente de si el código en un bloque "try" o "catch" se ejecuta correctamente, ciertos procedimientos deben realizarse siempre. Vamos a desentrañar la utilidad y el correcto uso del "finally".
¿Qué es y por qué es importante "finally"?
El bloque "finally" ejecuta código que, sin importar si ocurre o no una excepción, debe correr necesariamente. Es crucial, por ejemplo, para liberar recursos o cerrar conexiones, incluso en caso de una excepción no capturada. Esto asegura que el programa mantenga operaciones limpias y seguras.
Ejemplo práctico con "finally"
Considere un programa donde se recoge una nota de evaluación. Se espera que dicha nota esté en el rango de 0 a 5. Definimos un comportamiento con "try" y se captura una excepción si el valor no es el esperado. No obstante, imprimimos un aviso con sonido utilizando el bloque "finally":
try {
// Código que puede provocar una excepción
} catch (Exception) {
// Manejo de excepción
} finally {
// Bloque que siempre se ejecuta
Console.WriteLine("Finally se ha ejecutado.");
Console.Beep(2500, 500); // Beep para indicar ejecución
}
Aquí, independientemente de si la entrada es correcta o no, el marcado acústico avisa que se llegó al bloque "finally".
¿Qué sucede cuando un programa termina abruptamente?
Incluso si un programa se ve interrumpido bruscamente, como por una excepción no capturada o un comando explícito de "return", el "finally" se ejecuta. Este esquema es esencial en aplicaciones que exigen ejecutar ciertos procesos previo a su cierre definitivo.
Comparación entre "catch" y "finally"
Aunque "catch" captura y maneja excepciones específicas, "finally" garantiza la ejecución de clausuras críticas, como limpiar apuntadores o cerrar archivos:
- "catch": Captura y maneja una excepción específica.
- "finally": Ejecuta su código siempre, incluso si ocurren o no excepciones.
Buenas prácticas al manejar excepciones
El manejo eficaz de excepciones no solo reside en capturar errores, sino principalmente en intentar prevenirlos. Aquí te ofrecemos algunas prácticas recomendadas:
- Prevención de excepciones: Antes de realizar operaciones como divisiones, siempre verifica que el divisor no sea cero.
- Uso adecuado de "finally": Garantiza que las operaciones críticas se ejecuten siempre, como cerrar conexiones a bases de datos.
- Excepciones específicas: Prioriza capturar excepciones mediante tipos específicos, antes que el genérico
Exception. - Recuperación inteligente: Cuando es posible, refuerza el flujo post-excepción para que el programa continúe sin interrupciones evidentes para el usuario.
Al integrar estas metodologías, construimos aplicaciones más sólidas y menos propensas a fallos inesperados. La implementación adecuada de bloques "finally" en tus programas podría marcar la diferencia en el manejo de errores y la integridad general de tus aplicaciones. ¡Sigue explorando y optimizando tus conocimientos en programación!