Cargando...

try and catch

Envuelve la lectura mala de slots[5] en try y catch para que el programa no termine en IndexOutOfRangeException. Imprime blocked dentro del catch y luego after fuera de ambos bloques. Compila Pine y ejecuta dotnet run. La pantalla debe mostrar blocked y luego after. Un segundo archivo mantiene slots[0] dentro de try para que se omita el catch y la pantalla muestre 2 y luego after. Deja throw para la página siguiente.

Capturar el índice malo

La página de excepciones mostró que imprimir slots[5] sobre {2, 4} lanza IndexOutOfRangeException y detiene la ejecución. Esta página mantiene la misma historia del arreglo y añade el manejo. Abre un archivo de enseñanza nuevo llamado Pine. Mantén el nombre de clase pública Pine para que coincida con el nombre del archivo. Borra mains sobrantes de bare exceptions que se detienen sin catch, listas de y cualquier o ReadLine. El programa no debe esperar escritura.
Dentro de main, mantén el mismo arreglo pequeño:
int[] slots = {2, 4};
Pon la impresión mala dentro de try:
Console.WriteLine(slots[5]);
Luego escribe un catch que nombre IndexOutOfRangeException e imprima blocked. Después de todo el try y catch, imprime after. El nombre del parámetro del catch puede ser una letra corta como e; no necesitas imprimir el objeto de la excepción en esta página.

Pine catch bad index

csharp
using System;

public class Pine
{
    public static void Main()
    {
        int[] slots = {2, 4};
        try
        {
            Console.WriteLine(slots[5]);
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("blocked");
        }
        Console.WriteLine("after");
    }
}

Desde la carpeta que guarda Pine, ejecuta dotnet run. Cuando coincidan paréntesis, llaves y punto y coma, javac no escribe una línea propia. Luego ejecuta dotnet run — no dotnet run.java. Quita el final .java del comando de ejecución.
La pantalla muestra blocked y luego after. El índice malo sigue lanzando dentro de try. El catch maneja esa excepción nombrada e imprime blocked. La línea Console.WriteLine("after"); está fuera, así que también se ejecuta. El programa no termina en esa parada como el archivo malo desnudo de bare exceptions.
Imagina una segunda impresión aún dentro del mismo try después de slots[5], por ejemplo una línea que imprimiría rice. Esa línea no se ejecuta. Capturar la excepción no vuelve a terminar el resto de try. Solo el cuerpo del catch corre para esa parada; luego el control sigue después del catch. Mantén clara la idea: el manejo omite las líneas restantes dentro de try después del punto de lanzamiento.
Si la terminal espera entrada de teclado, aún hay una llamada ReadLine de un ejercicio antiguo en un archivo. Bórrala. Si solo ves un informe de pila sin la línea blocked, falta el catch o el nombre de la excepción no coincide. Si ves solo 2 sin after, quizá aún ejecutas un bare exceptions seguro antiguo — pasa a dotnet run con el archivo de enseñanza del catch.

Cuando try termina, catch se queda en silencio

Un segundo programa usa la misma forma de try y catch, pero la impresión dentro de try pide un hueco escrito: slots[0]. Todas las líneas dentro de try terminan. El cuerpo del catch no se ejecuta.

Pine safe index skips catch

csharp
using System;

public class Pine
{
    public static void Main()
    {
        int[] slots = {2, 4};
        try
        {
            Console.WriteLine(slots[0]);
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("blocked");
        }
        Console.WriteLine("after");
    }
}

Compila con dotnet run y luego ejecuta dotnet run. La pantalla muestra 2 y luego after. La palabra blocked no se imprime, porque no hubo IndexOutOfRangeException. El catch se quedó en silencio. La línea after sigue ejecutándose porque está fuera de ambos bloques — el mismo lugar que en la demo del catch.
Recorre el contraste una vez. Primer archivo: índice malo, catch imprime blocked, luego after. Segundo archivo: índice seguro, catch omitido, pantalla 2 luego after. Ambos mantienen Pine y el mismo nombre de tipo del catch. Solo cambia el índice dentro de try. Ese único cambio basta para ver cuándo corre el catch y cuándo no.
No inventes un throw en esta página. Estás capturando una excepción que ya provoca una lectura mala del arreglo. La página siguiente trata de lanzar a propósito. Tampoco envuelvas hoy cada impresión tranquila del curso dentro de try — esta lección usa try donde un índice malo conocido necesita un camino manejado.

El nombre del catch debe coincidir

La cláusula catch nombra un tipo de excepción. En esta página ese tipo es IndexOutOfRangeException, coincidiendo con el índice malo. Si escribieras catch (NullReferenceException e) alrededor de slots[5], ese catch no manejaría la parada. El programa seguiría terminando con IndexOutOfRangeException, y no se imprimirían ni blocked ni after para ese catch que no coincide. Mantén el tipo coincidente en los archivos de enseñanza.
Existen otros nombres de excepción en C#. Esta página se queda con un par claro: un índice malo de arreglo y IndexOutOfRangeException. No necesitas un catálogo de cada tipo capturable antes de practicar esta forma. Haz coincidir el nombre que viste en la página de excepciones.

Comparado con la parada desnuda de bare exceptions

En la página de excepciones, dotnet run con slots[5] se detuvo y mostró un informe de pila. En esta página, dotnet run con el mismo índice malo imprime blocked y continúa hasta after. La historia del arreglo no cambió. El manejo sí. Mantén archivos bare exceptions solo como historia si aún están cerca; ejecuta dotnet run para las demos del catch para que la pantalla coincida con esta lección.
La historia de nullable sigue imprimiendo 9 desde una lista si conservas ese archivo antiguo. Ese camino no es la historia del catch. Borra o ignora demos sobrantes de int? dentro de Pine para que el archivo de enseñanza se quede en int[] slots más try y catch.

Lo que esta página deja para throwing

Esta página captura una excepción que una línea ya encuentra. La página siguiente introduce throw para que señales un problema tú mismo. Quédate aquí con un catch que coincida y con ver que after continúa. Aún no añadas un throw manual como requisito en estos archivos Pine.

Antes de throwing

Puedes capturar IndexOutOfRangeException desde slots[5] y ver blocked, luego after. Puedes mantener slots[0] dentro de try y ver 2, luego after, con el catch omitido. Compila Pine y ejecuta dotnet run para cada demo guardada por turno. El nombre del catch coincidió con la parada del índice malo. La página siguiente es throwing, donde provocas una parada a propósito.
Mantén la demo del catch para un camino manejado. Mantén el try seguro para omitir el catch en silencio. Mantén el throw manual fuera de esta página. Esos tres hábitos son el punto de control antes de seguir. Cuando aparezcan blocked y luego after tras la ejecución del índice malo de dotnet run, try y catch hicieron su trabajo para esta lección y estás listo para el siguiente tema sobre throwing.

🧠 Pon a Prueba tu Conocimiento

Listo para Empezar

Pon a Prueba tu Conocimiento

Ponte a prueba con este cuestionario interactivo y descubre qué tan bien entiendes el tema

❓
5
Preguntas
🎯
70%
Para Aprobar
♾️
∞
Tiempo
🔄
∞
Intentos

📝 Instrucciones

  • Lee cada pregunta cuidadosamente
  • Selecciona la mejor respuesta para cada pregunta
  • Puedes repetir el quiz tantas veces como quieras
  • Tu progreso se mostrará en la parte superior