CursosEmpresasBlogLiveConfPrecios

Tipos anónimos en LINQ para reportes complejos

Clase 28 de 35 • Curso de C# con .Net Core 2.1

Clase anteriorSiguiente clase
Resumen

Crear reportes potentes en C Sharp con LINQ es más simple cuando se aplica una regla clave: divide y vencerás. Aquí se diseña un reporte que agrupa por asignatura y devuelve el promedio de cada alumno en esa asignatura, reutilizando piezas previas, como el diccionario de evaluaciones por asignatura, y aprovechando tipos anónimos, IEnumerable y KeyValuePair en Visual Studio. Además, se refuerza cómo el razonamiento de SQL se traslada de forma natural a LINQ, incluso si apenas tienes proficiency inicial.

¿Cómo estructurar el reporte con LINQ y Visual Studio?

El objetivo es regresar un diccionario donde la clave sea la asignatura y el valor una colección con datos del alumno y su promedio. Para llegar ahí, primero se define la forma del retorno y se prepara el espacio para construir la respuesta.

  • Clave del diccionario: nombre de la asignatura.
  • Valor: colección con datos del alumno y su nota promedio.
  • Requisito: consultar evaluaciones por asignatura y promediar por alumno.
  • Estrategia: extraer piezas en métodos pequeños y reutilizables.
  • Visibilidad: métodos públicos si exponen funcionalidad general; privados si resuelven un caso interno.

Código base del método y respuesta inicial:

// Firma y respuesta inicial
Dictionary<string, IEnumerable<object>> GetPromedioDeAlumnosPorAsignatura()
{
    var rta = new Dictionary<string, IEnumerable<object>>();
    // Construcción de rta ocurre después de consultar y proyectar datos
    return rta;
}

¿Qué retorna el diccionario y por qué usar IEnumerable?

Al comienzo no existe un tipo concreto que combine “alumno” con “nota”. Por eso, se usa IEnumerable como marcador temporal. Más adelante, con tipos anónimos, se proyectan los campos necesarios sin definir una clase explícita. Así, se avanza sin bloquearse por el modelo de datos definitivo.

  • Tipo anónimo: permite devolver un “objeto compuesto” sin crear una clase.
  • Flexibilidad: se incluyen campos del alumno y la nota de la evaluación.
  • Iteración: el resultado es una colección; se recorre con foreach.

¿Cómo iterar el diccionario de evaluaciones por asignatura?

Se reutiliza el diccionario de evaluaciones por asignatura del reporte previo. Cada entrada es un KeyValuePair>: Key es la asignatura y Value la lista de evaluaciones. Se proyecta lo necesario con LINQ y se usa un tipo anónimo para devolver múltiples campos en una sola selección.

  • KeyValuePair: entrada con clave (string) y valor (lista de evaluaciones).
  • foreach: recorre cada asignatura y sus evaluaciones asociadas.
  • Select: proyecta los campos requeridos en un tipo anónimo.
  • Nota práctica: no se pueden devolver “dos cosas” sin un objeto compuesto.

Ejemplo de proyección y recorrido del resultado:

foreach (var asignaturaConEvaluaciones in dictEvalPorAsignatura)
{
    var dummy = asignaturaConEvaluaciones.Value.Select(ev => new
    {
        UniqueId = ev.Alumno.UniqueId, // *unique ID* del alumno
        Nota = ev.Nota,                // nota de la evaluación
        AlumnoNombre = ev.Alumno.Nombre,
        NombreEvaluacion = ev.Nombre
    });

    foreach (var item in dummy)
    {
        var id = item.UniqueId;
        var nota = item.Nota;
        // usar propiedades proyectadas sin conflictos
    }
}
  • Importante: el resultado de la proyección es una colección; por eso se itera. En consultas con into, el resultado también se trata como lista, incluso con un solo elemento.

¿Cómo evitar conflictos de nombres en tipos anónimos?

Si proyectas dos propiedades con el mismo nombre (por ejemplo, Nombre del alumno y Nombre de la evaluación), se produce un conflicto. La solución es renombrar las propiedades en la proyección.

  • Uso recomendado: AlumnoNombre y NombreEvaluacion.
  • Beneficio: lectura clara y sin errores del compilador.
  • Resultado: acceso simple a item.AlumnoNombre y item.NombreEvaluacion.

¿Cómo calcular el promedio por alumno en cada asignatura?

La meta es que cada asignatura muestre, para cada alumno, el promedio de sus evaluaciones. Un alumno puede tener varias evaluaciones en la misma asignatura; por eso, el paso clave es consolidar esas notas antes de formar la respuesta final.

  • Enfoque: pensar en agrupar las evaluaciones por unique ID del alumno dentro de cada asignatura.
  • Cálculo: obtener la media de Nota para ese alumno y asignatura.
  • Resultado esperado: por asignatura, una colección con alumno y su promedio.
  • Nota: la solución completa del cálculo se desarrolla a continuación del diseño mostrado.

Habilidades y conceptos reforzados:

  • Divide y vencerás: descomponer problemas complejos en métodos pequeños y reutilizables.
  • LINQ vs SQL: lógica de consulta similar; el cambio es de sintaxis, no de razonamiento.
  • Diccionarios: clave string (asignatura) y valor colecciones de evaluaciones.
  • Tipos anónimos: devolver múltiples campos sin crear clases explícitas.
  • IEnumerable: trabajar con secuencias y diferir la ejecución.
  • KeyValuePair: modelo de entrada al recorrer diccionarios.
  • foreach: recorrer colecciones proyectadas por LINQ.
  • Diseño de métodos: públicos para funcionalidades generales; privados para utilidades internas.

¿Tienes dudas sobre la proyección con tipos anónimos o cómo estructurar el diccionario por asignatura? Comparte tu comentario y cuéntame cómo lo estás resolviendo.

      Tipos anónimos en LINQ para reportes complejos