Introducción

1

Programación Avanzada en C# con Netcore

Etapa 5 – POO reutilicemos nuestro código

2

Reutilización de Código en C y Programación Orientada a Objetos

3

Herencia y Polimorfismo en Programación Orientada a Objetos

4

Polimorfismo en Programación Orientada a Objetos

5

Polimorfismo en Programación: Uso y Errores Comunes en Visual Studio

6

Validación y Conversión de Tipos en C# para Gestión de Objetos Escuela

7

Sobrescritura de Método ToString para Depuración Eficiente

Etapa 6- Ajustes y funcionalidad

8

Implementación de Interfaces en Programación Orientada a Objetos

9

Uso de Interfaces y Polimorfismo en Visual Studio Code

10

Uso de Regiones en Visual Studio para Mejorar la Legibilidad del Código

Etapa 7 – Preparando información para nuestros reportes

11

Manejo Avanzado de Métodos y Parámetros en Programación

12

Manejo de Parámetros de Salida en Visual Studio Code

13

Sobrecarga de Métodos para Parámetros de Salida Opcionales

14

Optimización de Listas: Buenas Prácticas en C#

15

Uso de Diccionarios en C# para Gestión de Datos en Aplicaciones

16

Creación y Manejo de Diccionarios en C# para Aplicaciones Escolares

17

Uso de Constantes y Enumeraciones para Optimizar Diccionarios en C#

18

Creación y Manejo de Diccionarios en C# para Gestión Escolar

19

Impresión de Diccionarios en Visual Studio con C#

20

Filtrado y Personalización de Impresión en C#

21

Uso del operador switch en Visual Studio para optimizar código

22

Optimización de Algoritmos y Eventos en C#

23

Diccionarios y Refactoring en Programación Básica

Etapa 8 – Consultas

24

Consultas y Reportes en Proyectos C# Básicos

25

Generación segura de reportes en sistemas de información

26

Generación de Reportes en Visual Studio Code

27

Creación de Reporte de Evaluaciones por Asignatura en Programación OO

28

Creación de Reportes Complejos con LinQ en Visual Studio

29

Cálculo del Promedio de Notas Agrupadas por Alumno y Asignatura

30

Creación de Tipos de Datos Personalizados en Programación Avanzada

31

Generación de Reportes con LINQ en C#

Etapa 9 – Creando una UI de Consola

32

Manejo de Excepciones y Captura de Datos en Consola en C#

33

Manejo de Excepciones en C#: Try, Catch y Finally

34

Creación de Menú de Reportes en Consola en C

35

Evaluación y Retroalimentación del Curso Básico de C

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Manejo de Excepciones en C#: Try, Catch y Finally

33/35
Recursos

¿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:

  1. Prevención de excepciones: Antes de realizar operaciones como divisiones, siempre verifica que el divisor no sea cero.
  2. Uso adecuado de "finally": Garantiza que las operaciones críticas se ejecuten siempre, como cerrar conexiones a bases de datos.
  3. Excepciones específicas: Prioriza capturar excepciones mediante tipos específicos, antes que el genérico Exception.
  4. 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!

Aportes 12

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Un ejemplo de uso finally que me pareció bueno para ejemplificar su uso es si, hay que leer un archivo o conectarse a una base de datos

try {
	// Abrir conexion a la BD
	// Conectarse a la BD y hacer cosas
} catch (E) {
	// Error por X motivo
} finally {
	// Cerrar conexion a la BD
	// No importa lo que pase, SIEMPRE hay que cerrar la conexión a la BD.
}

Saludos!

El lo dijo relajando, pero aquí estoy haciendo mi canción, noche de paz, noche de amor en beeps 😃 jajajaja

“nuestro amigo el pito”

Siempre que sepamos que una exception va ocurrir se debe evitar. lanzarla. Donde no se puede controlar siempre hay que retomar el flujo del programa y si no es posible retomar el programa el flujo debe terminar con un mensaje amigable al usuario
Maestro Juan Carlos Ruiz.

EN este caso yo empleo finally cuando deseo cerrar recursos como son conexiones, archivos, procesos threads entre otras factores

< try{

            }catch(Exception e)
            {

            }
            finally
            {

            }>

El objetivo de este bloque es liberar recursos que se solicitan en el bloque try. El bloque finally se ejecuta siempre, inclusive si se genera la captura de una excepción.

Los recursos más comunes que se deben liberar son las conexiones a bases de datos, uso de archivos y conexiones de red. Un recurso que no se libera impide que otro programa lo pueda utilizar. Al disponer la liberación de recursos en el bloque ‘finally’ nos aseguramos que todo recurso se liberará, inclusive aunque se dispare una excepción. Tener en cuenta que si no se disparan ninguna excepción en un bloque try luego de esto se ejecuta el bloque ‘finally’.

El “Finally” siempre se ejecuta antes que el programa se cierre, su importancia es que hay programas que siempre necesitan realizar una acción antes que se quiere realizar una acción de excepción controlada o no, está relacionada con cerrar apuntadores, enviar mensajes, cerrar cosas que deben estar cifradas.

try
{
   newEval.Nota = float.Parse(nota);
   if(newEval.Nota < 0 || newEval.Nota > 5)
{
    throw new ArgumentOutOfRangeException("La nota debe estar entre 0 y 5");
}
   WriteLine("La nota de la evaluación ha sido ingresado correctamente");
}
catch(ArgumentOutOfRangeException Ex){
    Printer.WriteTitle(Ex.Message);
     WriteLine("Saliendo del programa");
 }
catch (Exception){
    Printer.WriteTitle("El valor de la nota no es un número válido");
    WriteLine("Saliendo del programa");
}
finally{
    Printer.WriteTitle("Finally");
    Printer.Beep(2500, 500, 3);
}

El finally, siempre es pregunta de entrevista para .net developer

el finally completa el catch , lo maximo.

Esos beeps me recordaron el puzzle de las muestras de agua dentro de la fabrica muerta en Resident Evil 3 jajaja

Excelente Clase ya me quedo claro la Sentencia Finally la empezare a utilizar

Y si existen try anidados, ¿Cómo se comportarían?

😎