Conversiones seguras en C# con is y as

Domina conversiones seguras en C# con los operadores is y as, evita excepciones en tiempo de ejecución y aprende a construir un método que recolecta todos los objetos de una escuela en una sola lista. Con un enfoque práctico en Visual Studio Code y apoyo del debugger, verás cómo blindar tu código y preparar el terreno para clasificar objetos por tipo.

¿Cómo evitar excepciones al convertir tipos en C# con is y as?

Usar conversiones sin validar dispara errores en tiempo de ejecución. La estrategia es sencilla: primero comprueba el tipo, luego convierte. Con is verificas compatibilidad y con as obtienes el objeto o nul sin romper la ejecución.

¿Cuándo usar is?

El patrón es comprobar y hacer casting explícito. Si no coincide, no ejecuta y evitas la excepción.

if (objeto is Alumno)
{
    var alumnoRecuperado = (Alumno)objeto; // Conversión segura tras validar.
    // Usar alumnoRecuperado.
}

Puntos clave:

• is confirma si el objeto es de un tipo específico.
• Si no coincide, el bloque no se ejecuta y no hay excepción.
• Útil cuando necesitas lógica condicionada al tipo.

¿Cuándo usar as?

as intenta convertir y, si no puede, devuelve nul. No lanza excepción y el flujo es más limpio. Según la explicación, es la opción más recomendada por su claridad y menor código.

var alumnoRecuperado2 = objeto as Alumno;
if (alumnoRecuperado2 != null)
{
    // Usar alumnoRecuperado2 con confianza.
}

Buenas prácticas:

• Siempre valida nul tras usar as.
• Evita conversiones directas sin verificación previa.
• Prefiere as cuando luego vas a usar el objeto convertido.

¿Cómo construir un método para obtener todos los objetos de escuela?

La meta: devolver una colección con todos los elementos del modelo escolar. La escuela en sí, sus cursos, asignaturas, alumnos y evaluaciones. Se propone un método público que retorna List<ObjetoEscuelaBase>.

¿Qué objetos incluye la colección?

La lista debe agrupar todo lo que compone la escuela.

• La escuela como objeto raíz.
• Los cursos de la escuela.
• Las asignaturas de cada curso.
• Los alumnos de cada curso.
• Las evaluaciones de cada alumno.

¿Cómo recorrer cursos, alumnos y evaluaciones?

Se inicia con la escuela, se agregan los cursos, luego se navega con foreach para sumar asignaturas, alumnos y, finalmente, evaluaciones.

public List<ObjetoEscuelaBase> GetObjetosDeEscuela()
{
    var listaObj = new List<ObjetoEscuelaBase>();

    // 1) Escuela.
    listaObj.Add(this); // La escuela actual.

    // 2) Cursos.
    listaObj.AddRange(Cursos);

    // 3) Asignaturas, alumnos y evaluaciones.
    foreach (var curso in Cursos)
    {
        listaObj.AddRange(curso.Asignaturas);
        listaObj.AddRange(curso.Alumnos);

        foreach (var alumno in curso.Alumnos)
        {
            listaObj.AddRange(alumno.Evaluaciones);
        }
    }

    return listaObj;
}

Claves de implementación:

• Usa Add para la escuela y AddRange para colecciones.
• Recorre con foreach para aplanar jerarquías.
• Retorna la lista completa para reportes o inspección.

¿Qué limitaciones tiene la lista y por qué pensar en un diccionario por tipo?

Al ejecutar y depurar, se obtiene una lista con todos los objetos. Se reportó un volumen grande: 1181 objetos entre alumnos, cursos, asignaturas y evaluaciones. El debugger muestra tipos, pero poca información inmediata de cada instancia.

Limitaciones observadas:

• La lista mezcla tipos y no facilita filtrado inmediato por clase.
• En el debugger, identificar detalles requiere abrir cada elemento.
• Para reportes, es útil obtener solo cursos, o solo asignaturas, sin recorrer todo.

Propuesta de mejora:

• Cambiar la salida de lista a diccionario que clasifique intencionalmente por tipo.
• Beneficios: acceso directo por categoría, filtrado inmediato, código más claro para reportes.

¿Te gustaría ver la clasificación por tipo con un diccionario y ejemplos prácticos de acceso? Cuéntame qué colección usarías y qué reportes te interesan generar.