Herencia para reutilizar código C#

Aprende a reutilizar código en C# con programación orientada a objetos: renombrar entidades correctamente, organizar evaluaciones por alumno, evitar listas nulas y sentar las bases de herencia para eliminar duplicación. Verás cómo depurar en Visual Studio y mejorar la eficiencia con listas genéricas.

¿Cómo corregir y organizar las evaluaciones en C#?

Elegir una estructura clara evita errores y simplifica la lógica. Primero, corrige el nombre de la entidad: usa singular “Evaluación”. En Visual Studio, emplea “renombrar símbolo” para actualizar referencias de forma segura. Mantén consistencia incluso en el nombre del archivo.

• Nombres de entidades en singular para coherencia.
• Corrección con “renombrar símbolo” en Visual Studio.
• Decisión de diseño: las evaluaciones viven en el alumno.

Implementa que cada alumno sea portador de su propia lista. Así logras una doble referencia: cada Evaluación conoce a su Alumno, y cada Alumno tiene su lista de Evaluaciones. Esto facilita consultas por alumno o por evaluación.

public class Evaluación
{
    public string Nombre { get; set; }
    public Alumno Alumno { get; set; }
    public float Nota { get; set; }
    public string Asignatura { get; set; }
}

public class Alumno
{
    public string Nombre { get; set; }
    public string Id { get; set; } // id único
    public List<Evaluación> Evaluaciones { get; set; } = new List<Evaluación>();
}

Claves prácticas:

• Inicializa la lista para evitar null.
• Genera evaluaciones aleatorias por alumno.
• Mantén la referencia Evaluación.Alumno al momento de crear cada evaluación.

¿Cómo se asignan las evaluaciones al alumno?

Puedes agregar una por una o usar un enfoque más eficiente con AddRange.

// Opción 1: agregar una por una
foreach (var alumno in curso.Alumnos)
{
    for (int i = 0; i < 5; i++)
    {
        var ev = new Evaluación { Alumno = alumno /* ... */ };
        alumno.Evaluaciones.Add(ev);
    }
}

// Opción 2: más eficiente con AddRange
foreach (var alumno in curso.Alumnos)
{
    var lote = new List<Evaluación>();
    for (int i = 0; i < 5; i++)
    {
        var ev = new Evaluación { Alumno = alumno /* ... */ };
        lote.Add(ev);
    }
    alumno.Evaluaciones.AddRange(lote);
}

Resultado esperado: si hay 4 asignaturas y creas 5 evaluaciones por asignatura, cada alumno acumula 20 evaluaciones.

¿Cómo evitar errores comunes y depurar con seguridad?

Durante la asignación, el fallo típico es: la lista Evaluaciones es nula. La solución: inicializa la propiedad en su declaración o en el constructor. Con eso, la colección existe aunque esté vacía.

• Inicializa listas genéricas desde el inicio.
• Revisa referencias antes de agregar.
• Usa debug paso a paso para validar el flujo.

Pasos de depuración en Visual Studio:

• Coloca un breakpoint en la sección donde asignas evaluaciones.
• Entra al método de inicialización del engine.
• Verifica que Evaluación.Alumno se asigne dentro del bucle.
• Inspecciona Alumno.Evaluaciones para confirmar el conteo tras cada iteración.

Patrón seguro para listas:

public class Alumno
{
    public List<Evaluación> Evaluaciones { get; set; } = new List<Evaluación>();
}

Beneficios inmediatos:

• Evitas excepciones por referencia nula.
• Aseguras la doble referencia entre Alumno y Evaluación.
• Aceleras el llenado con AddRange cuando generas lotes.

¿Cómo reducir duplicación con herencia en POO?

Si Alumno, Asignatura, Curso y Escuela comparten “Id único” y “Nombre”, estás repitiendo lógica. La herencia resuelve esto: crea una clase base con lo común y haz que las demás hereden. Así centralizas la responsabilidad y facilitas el mantenimiento.

• Extrae propiedades compartidas a una clase base.
• Hereda en entidades concretas para reutilizar código.
• Mantén una sola fuente de verdad para el Id único y el nombre.

Ejemplo orientativo:

public abstract class EntidadBase
{
    public string Id { get; set; }
    public string Nombre { get; set; }
}

public class Alumno : EntidadBase
{
    public List<Evaluación> Evaluaciones { get; set; } = new List<Evaluación>();
}

public class Asignatura : EntidadBase { }
public class Curso : EntidadBase { }
public class Escuela : EntidadBase { }

Ventajas claras:

• Menos duplicación y menos errores.
• Estandarización del Id único y del nombre.
• Código más legible y fácil de extender.

¿Tienes otra forma de estructurar las evaluaciones o la clase base? Comparte tus dudas o mejoras en los comentarios.