Refactorización de Métodos en C# para Eficiencia de Código

Optimiza la inicialización de datos en C# aplicando responsabilidad única, extracción de métodos en Visual Studio Code y LINQ para generar alumnos mediante producto cartesiano. Verás cómo cargar cursos, asignaturas y alumnos de forma clara, evitando métodos gigantes, errores de implementación y IDs duplicados.

¿Cómo refactorizar métodos largos en C# con responsabilidad única?

Dividir tareas grandes en piezas pequeñas hace el código más legible y mantenible. Si un método supera ~50 líneas, conviene separarlo. Con el bombillito de VS Code puedes extraer método: son sugerencias, no correcciones, que aceleran el trabajo.

• Un método o clase debe tener una sola responsabilidad.
• Usa Control + punto para extraer método rápidamente.
• Crea métodos: cargar cursos, cargar asignaturas, cargar alumnos.
• Usa throw new NotImplementedException() como recordatorio de implementación pendiente.

void CargarCursos() { /* inicializa cursos */ }

IEnumerable<Alumno> CargarAlumnos()
{
    throw new NotImplementedException();
}

void CargarAsignaturas()
{
    throw new NotImplementedException();
}

¿Cómo cargar asignaturas a cada curso de forma segura?

Las asignaturas base son: Matemáticas, Educación física, Castellano y Ciencias naturales. Se agregan a cada curso con una lista nueva por curso para evitar IDs compartidos.

• Crea la lista de asignaturas dentro del bucle por curso.
• Usa AddRange sobre la colección de asignaturas del curso.
• Evita construir una única lista fuera del bucle: duplicaría el mismo unique ID por asignatura en todos los cursos.

foreach (var curso in escuela.Cursos)
{
    var asignaturas = new List<Asignatura>
    {
        new Asignatura { Nombre = "Matemáticas" },
        new Asignatura { Nombre = "Educación física" },
        new Asignatura { Nombre = "Castellano" },
        new Asignatura { Nombre = "Ciencias naturales" }
    };

    curso.Asignaturas.AddRange(asignaturas);
}

• Idea clave: instancias nuevas por curso evitan conflictos con el unique ID.
• Beneficio: código simple, claro y sin efectos colaterales.

¿Cómo generar alumnos con combinatoria usando LINQ?

En lugar de foreach anidados para la combinatoria de nombres, usa el lenguaje integrado de consultas, LINQ, de forma declarativa como en SQL con select y from.

• Arreglos de ejemplo: nombres, segundos nombres y apellidos.
• Producto cartesiano con LINQ para combinar todo contra todo.
• Retorna un IEnumerable<Alumno> y asígnalo a cada curso con AddRange.

using System.Linq; // necesario para consultas LINQ

var nombres1 = new[] { "Alba", "Felipa", "Eusebio", "Farid", "Donald", "Álvaro", "Nicolás" };
var nombres2 = new[] { "Freddy", "Anabel", "Rick and Morty", "Silvana", "Diomedes", "Nicomedes", "Teodoro" };
var apellidos = new[] { "Ruiz", "Sarmiento", "Uribe", "Maduro", "Trump", "Toledo", "Herrera" };

IEnumerable<Alumno> CargarAlumnos()
{
    var alumnos =
        from n1 in nombres1
        from n2 in nombres2
        from a1 in apellidos
        select new Alumno { Nombre = $"{n1} {n2} {a1}" };

    return alumnos; // IEnumerable<Alumno>
}

var listaA = CargarAlumnos();
foreach (var curso in escuela.Cursos)
{
    curso.Alumnos.AddRange(listaA);
}

• Declarativo con LINQ: menos código y mayor expresividad que foreach anidados.
• Conceptos clave: producto cartesiano, select, from, where (cuando aplique).
• Si aparece error de patrón de consulta: agrega using System.Linq.

¿Te gustaría ver variantes con filtros o límites sobre la combinatoria, o proponer tus propios conjuntos de nombres? Comparte tus ideas y dudas en los comentarios.