El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Manejo de Excepciones

Siguiente ►
►

El manejo de excepciones es una parte crucial de la programación en C#. Permite a los desarrolladores gestionar errores y situaciones inesperadas de manera controlada, mejorando la robustez y la fiabilidad de las aplicaciones.

Conceptos Clave

  1. Excepción: Un evento que ocurre durante la ejecución de un programa y que interrumpe el flujo normal de las instrucciones.
  2. Try-Catch: Bloques de código utilizados para capturar y manejar excepciones.
  3. Finally: Un bloque opcional que se ejecuta siempre, independientemente de si se lanzó una excepción o no.
  4. Throw: Una instrucción utilizada para lanzar una excepción de manera explícita.

Estructura Básica del Manejo de Excepciones

La estructura básica para manejar excepciones en C# utiliza los bloques try, catch y finally. A continuación se muestra un ejemplo simple:

try
{
    // Código que puede lanzar una excepción
}
catch (Exception ex)
{
    // Código para manejar la excepción
}
finally
{
    // Código que se ejecuta siempre, independientemente de si hubo una excepción o no
}

Ejemplo Práctico

Vamos a ver un ejemplo práctico donde intentamos dividir dos números y manejamos posibles excepciones:

using System;

class Program
{
    static void Main()
    {
        try
        {
            Console.WriteLine("Ingrese el numerador:");
            int numerador = Convert.ToInt32(Console.ReadLine());

            Console.WriteLine("Ingrese el denominador:");
            int denominador = Convert.ToInt32(Console.ReadLine());

            int resultado = numerador / denominador;
            Console.WriteLine($"El resultado es: {resultado}");
        }
        catch (DivideByZeroException ex)
        {
            Console.WriteLine("Error: No se puede dividir por cero.");
        }
        catch (FormatException ex)
        {
            Console.WriteLine("Error: Entrada no válida. Por favor, ingrese un número entero.");
        }
        finally
        {
            Console.WriteLine("Operación finalizada.");
        }
    }
}

Explicación del Código

  1. Bloque try: Contiene el código que puede lanzar una excepción. En este caso, estamos leyendo dos números del usuario y realizando una división.
  2. Bloque catch: Captura y maneja las excepciones específicas. Aquí tenemos dos bloques catch:
    • DivideByZeroException: Maneja el caso en que el denominador es cero.
    • FormatException: Maneja el caso en que la entrada no es un número entero válido.
  3. Bloque finally: Se ejecuta siempre, independientemente de si se lanzó una excepción o no. En este caso, simplemente imprime un mensaje indicando que la operación ha finalizado.

Lanzar Excepciones

En algunos casos, es posible que desees lanzar una excepción de manera explícita utilizando la instrucción throw. Aquí hay un ejemplo:

using System;

class Program
{
    static void Main()
    {
        try
        {
            int edad = -1;
            if (edad < 0)
            {
                throw new ArgumentOutOfRangeException("La edad no puede ser negativa.");
            }
        }
        catch (ArgumentOutOfRangeException ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

Explicación del Código

  1. Lanzar Excepción: Utilizamos throw para lanzar una excepción ArgumentOutOfRangeException si la edad es negativa.
  2. Capturar Excepción: El bloque catch captura y maneja la excepción, imprimiendo el mensaje de error correspondiente.

Ejercicio Práctico

Ejercicio

Escribe un programa que lea un número entero del usuario y calcule su raíz cuadrada. Maneja las siguientes excepciones:

  • FormatException si la entrada no es un número entero.
  • ArgumentOutOfRangeException si el número es negativo.

Solución

using System;

class Program
{
    static void Main()
    {
        try
        {
            Console.WriteLine("Ingrese un número entero:");
            int numero = Convert.ToInt32(Console.ReadLine());

            if (numero < 0)
            {
                throw new ArgumentOutOfRangeException("El número no puede ser negativo.");
            }

            double raizCuadrada = Math.Sqrt(numero);
            Console.WriteLine($"La raíz cuadrada de {numero} es {raizCuadrada}");
        }
        catch (FormatException ex)
        {
            Console.WriteLine("Error: Entrada no válida. Por favor, ingrese un número entero.");
        }
        catch (ArgumentOutOfRangeException ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
        finally
        {
            Console.WriteLine("Operación finalizada.");
        }
    }
}

Explicación del Código

  1. Leer Entrada: Leemos un número entero del usuario.
  2. Validar Número: Si el número es negativo, lanzamos una excepción ArgumentOutOfRangeException.
  3. Calcular Raíz Cuadrada: Calculamos la raíz cuadrada del número utilizando Math.Sqrt.
  4. Manejo de Excepciones: Capturamos y manejamos las excepciones FormatException y ArgumentOutOfRangeException.
  5. Bloque finally: Imprimimos un mensaje indicando que la operación ha finalizado.

Resumen

En esta sección, hemos aprendido sobre el manejo de excepciones en C#, incluyendo:

  • La estructura básica de try, catch y finally.
  • Cómo capturar y manejar excepciones específicas.
  • Cómo lanzar excepciones de manera explícita.
  • Ejemplos prácticos y un ejercicio para reforzar los conceptos.

El manejo adecuado de excepciones es esencial para crear aplicaciones robustas y confiables. En el próximo módulo, exploraremos las estructuras de control en C#, comenzando con las sentencias condicionales.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados