Generación de Reportes con LINQ en C#

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

Resumen

Este reto de C# básico te guía a crear un reporte con consultas Linq que devuelve el top X de promedios por asignatura. Practicarás cómo parametrizar, filtrar y ordenar resultados para obtener a los mejores estudiantes en materias como Matemáticas o castellano, mostrando su promedio de forma clara.

¿Cómo resolver el top de promedios con Linq en C#?

Crearás un reporte que recibe un parámetro numérico (el top) y una asignatura. Con eso, debes devolver los X mejores promedios de esa materia, incluyendo el nombre del estudiante y su promedio.

Recibir el top como parámetro (por ejemplo, 5 o 10).
Filtrar por asignatura solicitada (Matemáticas, castellano, etc.).
Ordenar por promedio y tomar los mejores X.
Mostrar estudiante y promedio por asignatura.
Reutilizar lo aprendido en consultas Linq para simplificar el reporte.

¿Qué entradas y salidas exige el reporte?

Entrada: número que indica el top X.
Entrada: asignatura a consultar.
Salida: lista con los mejores estudiantes y su promedio en esa asignatura.

¿Qué casos ejemplifica el instructor?

“Top cinco” de notas para Matemáticas con sus promedios.
“Top diez” para castellano con los promedios correspondientes.

¿Qué habilidades y conceptos refuerzas con consultas Linq?

Construir este reporte consolida habilidades clave: comprender promedios, aplicar filtros, ordenar resultados y limitar a un top X, todo con Linq. Además, refuerzas el diseño de reportes que reciben parámetros y devuelven resultados concretos.

Linq: consultas expresivas directamente en C#.
Extensión del lenguaje: Linq forma parte de C# y se integra nativamente.
Imperativo vs. declarativo: C# es principalmente imperativo, pero con Linq también es declarativo.
Sentencias declarativas: permiten operaciones que normalmente tomarían más trabajo.

¿Por qué C# también es declarativo con Linq?

Porque Linq es una extensión del lenguaje.
Porque sus sentencias expresan el “qué” sin detallar el “cómo”.
Porque con menos código describes filtros, ordenamientos y límites como top X.

¿Qué recomendaciones acompañan el reto de Linq?

Se sugiere aprovechar las lecturas recomendadas para ampliar el dominio de Linq: la referencia es amplia y cubre muchas situaciones que podrás resolver con esta herramienta.

Revisa material adicional para profundizar en Linq.
Usa la sección de comentarios para discutir soluciones.
Comparte los problemas que encuentres y debate la mejor solución.
Practica variando la asignatura y el top para validar tu enfoque.

¿Listo para intentarlo? Comparte en comentarios tu enfoque, los parámetros que probaste y qué asignaturas te dieron resultados más interesantes.

Omar Ismael Martínez Gómez

student•

Mi humilde solución:

        public Dictionary<string, IEnumerable<AlumnoPromedio>> GetListaTopPromedio(int x)
        {
            var resp = new Dictionary<string, IEnumerable<AlumnoPromedio>>();
            var dicPromAlumPorAsignatura = GetPromeAlumPorAsignatura();

            foreach (var item in dicPromAlumPorAsignatura)
            {
                var dummy = (from ap in item.Value
                             orderby ap.promedio descending
                             select ap).Take(x);

                resp.Add(item.Key, dummy);
            }

            return resp;
        }

Leniel Luzardo

student•

Me gusto tu solución! Simple y efectivo! :D Saludos!

Luis Abdel Rangel Castro

student•

Excelente!

Alexander Armúa Abregu

student•

Los problemas que tuve que resolver buscando por internet fueron:

Obtener primer elemento de la consulta, ya que por mas que el where devuelva un solo elemento sera en formato IEnumerable.
Ordenarlo de manera descendente por promedio.
Obtener la primera X cantidad de elementos.

Dejo mi solución:

public List<AlumnoPromedio> GetTopPromedioAlumnosEnAsignatura(string nombreAsignatura, int cantidad = 5) {
	var respuesta = new List<AlumnoPromedio>();
	var diccionarioPromediosPorAsignatura = GetPromedioAlumnoPorAsignatura();

	var alumnosFiltradosPorCantidad = 
		(from promedios in diccionarioPromediosPorAsignatura
			where promedios.Key.Equals(nombreAsignatura)
				select promedios.Value)
				.First() // Como siempre devuelve una lista, por mas que haya un elemento hay que tomar .First()
				.OrderByDescending(promedioAlumno => promedioAlumno.promedio)
				.Take(cantidad);
				
	respuesta.AddRange(alumnosFiltradosPorCantidad);

	return respuesta;
}

Saludos!

Alexander Armúa Abregu

student•

Podría mejorarse bastante la performance, evitando llamar a `GetPromedioAlumnoPorAsignatura()` y haciendo todas las consultas previas filtrando por materia y nota desde el principio. Pero supuse que a motivos del ejercicio es suficiente, luego se puede mejorar la complejidad algorítmica en gran medida.

Oscar Enrique Piñeros Ovalle

student•

Estoy de acuerdo contigo, es mucho mejor realizar la consulta directamente y evitar el llamado al método ‘GetPromedioAlumnoPorAsignatura’, realizando los filtros y el ordenamiento directamente. Pero para el enfoque que sea manejado en el curso en cuanto a la realización de los reportes, expongo mi propuesta:

Se extrae del diccionario los alumnos con su promedio por medio de la llave (materia).
Se realiza el ordenamiento de mayor a menor de acuerdo al promedio de los Alumnos.
Se selecciona el Top de alumnos de acuerdo a la cantidad deseada.

 public List<object> GetMejoresPromedioXAsignatura(string asignatura, int top = 10)
        {
            var rta = GetPromeAlumnnPorAsignatura();
            var asig = rta.GetValueOrDefault(asignatura).OrderByDescending(prom => ((AlumnoPromedio)prom).Promedio).Take(top);

            return asig.ToList();
        }```

Jimmy Andrey Sánchez Bustos

student•

Otra opción podría ser retornando un IEnumerable de tipo object para darle mayor flexibilidad y seguridad en cuanto a tipos al listado de promedios:

public IEnumerable<object> GetMejoresPromxAsig(string asignatura, int cantidad = 5)
{
	var promAlumxAsig = GetPromAlumxAsig();
	var rta = promAlumxAsig.GetValueOrDefault(asignatura).OrderByDescending(prom => ((AlumnoPromedio) 
            prom).promedio).Take(cantidad);

	return rta;
}

Alejandro Andrade Soriano

student•

Mi solucion del reto

Funcion para obtener un diccionario con el top de estudiantes.

Funcion para imprimir diccionarios.

Output

Guadalupe Giovanni Hernández Medina

student•

Mi solución :D

 public Dictionary<string, IEnumerable<object>> TopPromedio(int top)
        {
            var rta = new Dictionary<string, IEnumerable<object>>();
            var dicEvalXAsig = GetDicEvaluaXAsig();

            foreach (var asigConEval in dicEvalXAsig)
            {
                var promsAlumn = (from eval in asigConEval.Value
                                  group eval by new
                                  {
                                      eval.Alumno.UniqueId,
                                      eval.Alumno.Nombre
                                  }
                            into grupoEvalsAlumno
                                  select new AlumnoPromedio
                                  {
                                      alumnoid = grupoEvalsAlumno.Key.UniqueId,
                                      alumnoNombre = grupoEvalsAlumno.Key.Nombre,
                                      //Por cada mimbro del volumen de datos estraer el valor nota (asigConEval.Value)
                                      promedio = grupoEvalsAlumno.Average(evaluacion => evaluacion.Nota)
                                  }).OrderByDescending(aluP => aluP.promedio).Take(top);

                rta.Add(asigConEval.Key, promsAlumn);
            }

            return rta;
        }```

Byron Bustamante López

student•

Estuve pensando en hacer la misma consulta que hicimos con el método de obtener el promedio de alumnos por asignaturas pero estaría repitiendo código ya que la única diferencia que hay es que devolvemos el mismo diccionario de asignaturas con el top de promedios.

Por lo que mi solución ha sido llamar al método GetPromAluPorAsig, ordenarlo descendientemente por el promedio y coger el top que me pasan por parámetro, el código queda así:

public Dictionary<string, IEnumerable<PromedioAlumno>> GetTopAluPorAsig(int max) {
			var resp = new Dictionary<string, IEnumerable<PromedioAlumno>>();

			var dicPromAluPorAsig = GetPromAluPorAsig();
			foreach(var asig_aluProms in dicPromAluPorAsig) {
				var topProms = asig_aluProms.Value.Cast<PromedioAlumno>().OrderByDescending(e => e.promedio).Take(max);
				resp.Add(asig_aluProms.Key, topProms);
			}

			return resp;
		}

Wellington Gabriel Muñoz Vargas

student•

Hola Byron, Mu buena implementación del metodo. Solo una pequeña observación. El casting no es necesario, ya que ¨asig_aluProms.Value¨ de por si es un objecto de tipo ¨PromedioAlumno¨, por lo que el asig_aluProms.Value.Cast lo que esta haciendo es tansformar el ¨PromedioAlumno¨ en un IEnumerable<PromedioAlumno> que ya de por si lo es

Mariano Martinelli

student•

Hola Byron. Yo habia hecho algo similar perio me surgio una duda. Que valor tendrias que pasar en "max" para que te devuelva todos los registros, sin limitarlos a una cantidad, como funcionaba antes el metodo ?

Andres Felipe Campos Peñaranda

student•

Marvin Gonzalez

student•

Dejo los enlaces del vídeo

Introducción a LINQ (C#)
Operaciones básicas de consulta LINQ (C#)

Ginson Orellana

student•

Me base en los metodos anterior y tome como referencia ej ejemplo de TryGetValue, anque realice un Cast, public Dictionary<string, IEnumerable<AlumnoPromedio>> ObtenerTopAlumnos(int cantidadAlumnos) { var promXAlumno = ObtenerPromedioXAlumno(); var respuesta = new Dictionary<string, IEnumerable<AlumnoPromedio>>(); var listaAsignatura = ObtenerAsignatura(out var listaEvaluacion); foreach (var asig in listaAsignatura) { promXAlumno.TryGetValue(asig, out IEnumerable<Object> alup); var rs= (from p in alup.Cast<AlumnoPromedio>() orderby p.Promedio descending select p).Take(cantidadAlumnos); respuesta.Add(asig, rs); } return respuesta; }

Juan David Amaya Cardenas

student•

Hola @ginsorel

Cual es exactamente la pregunta?

rafael malanco velazquez

student•

Lissett Paez

student•

facil y sencillo... excelente aporte

Ariel Ricardo Delgadillo Terrazas

student•

Tuve que cambiar todos los Object por tipo AlumnoPromedio para poder ordenar por la propiedad promedio

Hugo Marte

student•

Excelente aporte, me paso lo mismo. Aquí te dejo otra forma de resolverlo: public Dictionary<string, IEnumerable<AlumnoPromedio>> GetTopPromeAlumPorAsignatura(int top) { var rta = new Dictionary<string, IEnumerable<AlumnoPromedio>>(); var listaPromXAsig = GetPromeAlumPorAsignatura();

        foreach (var asig in listaPromXAsig)
        {

            var listaAlumnosTopAsignaturas = listaPromXAsig[asig.Key].OrderByDescending(alumnoPromedio => alumnoPromedio.promedio).Take(top);
            rta.Add(asig.Key, listaAlumnosTopAsignaturas);


        }
        return rta;
    }

Adriana Selena Tito Ilasaca

student•

Muy aparte del reto es así como convertí todas las sentencias de LINQ de query syntax que es como nos enseño el profe Juan Carlos a Method Syntax.

 public IEnumerable<string> GetListSubject(out IEnumerable<Test> testList)
        {
            testList = GetListTest();

            return testList.Select(x => x.Subject.Name).Distinct();
        }

        public Dictionary<string, IEnumerable<Test>> GetTestsBySubject()
        {
            var dictionary = new Dictionary<string, IEnumerable<Test>>();
            var subjectsList = GetListSubject(out IEnumerable<Test> testsList);

            foreach (var subject in subjectsList)
            {
                var testListBySubject = testsList.Where(x => x.Subject.Name == subject);
                dictionary.Add(subject, testListBySubject);
            }
            return dictionary;
        }

        public Dictionary<string, IEnumerable<StudentAverange>> GetStudentAverageBySubject()
        {
            var studentAverageBySubjectDictionary = new Dictionary<string, IEnumerable<StudentAverange>>();
            var testDictionaryBySubject = GetTestsBySubject();

            foreach (var evalBySubject in testDictionaryBySubject)
            {

                var studentA = evalBySubject.Value.GroupBy(x => x.Student.Name);
                List<StudentAverange> studentAverange = new List<StudentAverange>();
                foreach (var studentScore in studentA)
                {
                    float average = studentScore.Average(x => x.Score);
                    string id = studentScore.First().Student.Id;
                    studentAverange.Add(new StudentAverange
                    {
                        StudentId = id,
                        StudentName = studentScore.Key,
                        Average = average
                    });
                }
                studentAverageBySubjectDictionary.Add(evalBySubject.Key, studentAverange);
            }
            return studentAverageBySubjectDictionary;
        }

        public Dictionary<string, IEnumerable<StudentAverange>> GetTopScoresBySubject(int numberOfTop = 1)
        {
            var topScoresList = new Dictionary<string, IEnumerable<StudentAverange>>();
            var testBySubjectAndStudent = GetStudentAverageBySubject();
            foreach (var evalBySubject in testBySubjectAndStudent)
            {
                var orderedList = evalBySubject.Value.OrderByDescending(x => x.Average)
                                                     .Take(numberOfTop);
                topScoresList.Add(evalBySubject.Key, orderedList);
            }
            return topScoresList;
        }

Faris Mustafa Maanan

student•

El método que he creado para devolver los x alumnos de una asignatura x, le he añadido otro método que despeja las tildes de los nombres de las asignaturas por si el usuario no introduce las tildes, ademas de igualar a minúsculas para la comparación.

public Dictionary<string, IEnumerable<object>> GetTopPromedioAsignatura(int num, string asignatura)
        {
            var datos = GetPromedioAlumnoAsignatura();
            var dicTop = new Dictionary<string, IEnumerable<object>>();


            foreach (var item in datos)
            {
                string Asign = EliminarTildes(item.Key);
                if(Asign.ToUpper() == asignatura.ToUpper())
                {
                var top = (from datatop in item.Value
                            orderby ((AlumnoPromedio)datatop).Promedio descending
                            select datatop).Take(num);
                
                dicTop.Add(item.Key, top);
                }
            }

            return dicTop;

        }```

public static string EliminarTildes(string palabra) { string normalizarstring = palabra.Normalize(NormalizationForm.FormD); StringBuilder text = new StringBuilder(); for(int i = 0; i < normalizarstring.Length; i++) { UnicodeCategory uc = CharUnicodeInfo.GetUnicodeCategory(normalizarstring[i]); if (uc != UnicodeCategory.NonSpacingMark) { text.Append(normalizarstring[i]); } } return (text.ToString().Normalize(NormalizationForm.FormC)); }```

Anderson Duarte Santos

student•

Bueno yo lo estuve intentando hacer de distintas formas pero la más pero que me pareció más simple es la siguiente

Reporteador.cs

   public Dictionary<string, IEnumerable<object>> GetPromeAlumnXAsig(
            // out Dictionary<string, IEnumerable<object>> ListGen,
            // out Dictionary<string, IEnumerable<object>> ListTop,
            int top = 10
        )
        {
            var rta = new Dictionary<string, IEnumerable<object>>();
            var dicEvalXAsig = GetDicEvalXAsig();
            
            foreach (var asigConEval in dicEvalXAsig)
            {
                var promsAlum = from eval in asigConEval.Value
                            group eval by new{
                                eval.Alumno.UniqueId,
                                eval.Alumno.Nombre

                            } 
                            into grupoEvalsAlumno
                            select new AlumnoPromedio
                            {
                                alumnoId = grupoEvalsAlumno.Key.UniqueId, 
                                alumnoNombre = grupoEvalsAlumno.Key.Nombre, 
                                promedio = grupoEvalsAlumno.Average( evaluac => evaluac.Nota )
                            };
                rta.Add(asigConEval.Key, promsAlum.OrderByDescending((lp) => lp.promedio).Take(top));
            }
            return rta;
        }

Program.cs

	    listaPromXAsig = reporteador.GetPromeAlumnXAsig();
            Printer.WriteTitle("Lista De Alumnos Destacados");
            foreach (var asig in listaPromXAsig)
            {
                Printer.WriteTitle($"   {asig.Key}");
                var itm = 1;
                foreach (var Prom in asig.Value)
                {
                    switch (itm)
                    {
                        case 1:
                            WriteLine($"Primer Lugar {Prom} Felicitaciones!");
                            break;
                        case 2:
                            WriteLine($"Segundo Lugar {Prom} Felicitaciones!");
                            break;
                        case 3:
                            WriteLine($"Tercer Lugar {Prom} Felicitaciones!");
                            break;
                        default:
                            WriteLine(Prom);
                            break;
                    }
                    itm++;
                }
                
                
            }

AlumnoPromedio.cs

	public override string ToString()
        {
            return $"Alumno: \"{alumnoNombre}\", Promedio: {promedio}";
        }

Williams Ramos

student•

Para invocar cada reporte desde Program.cs, puedes crear instancias de las clases que manejan tus reportes y llamar a sus métodos. Por ejemplo, si tienes un método GenerarReporte en tu clase de reportes, lo harías así:

class Program
{
    static void Main(string[] args)
    {
        // Instancia del reporte
        var reporte = new Reporte();

        // Invocación de los reportes
        var topMatematicas = reporte.GenerarReporte("Matemáticas", 5);
        var topCastellano = reporte.GenerarReporte("Castellano", 10);

        // Mostrar resultados
        Console.WriteLine(topMatematicas);
        Console.WriteLine(topCastellano);
    }
}

Asegúrate de que cada método retorne el formato correcto para que puedas imprimirlo en consola. Esto te permitirá ejecutar y validar los reportes sin necesidad de usar el depurador.

Williams Ramos

student•

Disculpe, pero alguien tiene el codigo de program.cs donde se envia la ejecucion de cada reporte del reporteador?. Gracias

fernando diez

student•

public Dictionary<string, IEnumerable<AlumnoPromedio>> GetMejoresPromedio(int valoPromedio)

{

var rta = new Dictionary<string, IEnumerable<AlumnoPromedio>>();

var dicProAlumXAsig = GetPromedioAlumPorAsignatura();

foreach (var item in dicProAlumXAsig)

{

var ranking = from alProm in item.Value

where alProm.promedio >= valoPromedio

orderby alProm.promedio descending

select alProm;

rta.Add(item.Key, ranking);

}

return rta;

}

Jose Gabriel Zaragoza

student•

Costó pero va quedando...

1: Crear un enum para las materias.

    public enum LlaveDiccionarioAsginaturas { 
    
        Matemática,
        Naturales,
        Sociales,
        Gimnasia
    }

que el promedio por asignatura (completo) devuelva el dic con el objeto AlumnoPromedio como value

public Dictionary<string, IEnumerable<AlumnoPromedio>> GetPromedioAlumnosXAsignatura()
        {
            var rta = new Dictionary<string, IEnumerable<AlumnoPromedio>>();
            var dicEvalXAsig = GetDicEvalPorAsig();
            foreach (var asignaturaConEvaluaciones in dicEvalXAsig)
            {
                var promediosAlumnos = from eval in asignaturaConEvaluaciones.Value
                                       group eval by new { 
                                           eval.Alumno.UniqueId,
                                           eval.Alumno.Nombre }
                                        into grupoEvalsAlumno
                                       select new AlumnoPromedio { 
                                           alId = grupoEvalsAlumno.Key.UniqueId, 
                                           promedio = grupoEvalsAlumno.Average(evaluacion => evaluacion.Nota), 
                                           alNombre = grupoEvalsAlumno.Key.Nombre };
                rta.Add(asignaturaConEvaluaciones.Key,promediosAlumnos);
            }

            return rta;
        }

Que GetTopPromedioAlumnosXAsignatura devuelva una lista de obetos tipo AlumnoPromedio

        public List<AlumnoPromedio> GetTopPromedioAlumnosXAsignatura(LlaveDiccionarioAsginaturas asignatura, int topCantidad = 5)
        {
            var rta = new List<AlumnoPromedio>();
            var dicPromediosAlumnosXasignatura = GetPromedioAlumnosXAsignatura();
            var soloListaPromediosAsignatura = dicPromediosAlumnosXasignatura[asignatura.ToString()];
            var topAlumnos = soloListaPromediosAsignatura.OrderByDescending(alumno => alumno.promedio).Take(topCantidad);
            rta.AddRange(topAlumnos);
            return rta;
        }

Eduardo Ortiz

student•

public List<object> TopFive(string materia, int rango) { var promedios = GetPromeAlumnPorAsignatura(); var top = promedios.GetValueOrDefault(materia).OrderByDescending(prom => ((AlumnoPromedio)prom).promedio ).Take(rango);

        return top.ToList();
    }

Andrés Felipe Sandoval Higuera

student•

Un aporte de mi solución con impresión de resultados:

		public IEnumerable<object> GetMejorAlumnoPromedioPorAsignatura(string asignatura, int cantidad = 5)
		{

			var promAlumxAsig = GetPromedioAlumnPorAsignatura();
			var rta = promAlumxAsig.GetValueOrDefault(asignatura).OrderByDescending(prom => ((AlumnoPromedio)
					prom).promedio).Take(cantidad);

			Printer.WriteTitle($"En la materia {asignatura} el mejor promedio Top {cantidad} de estudiantes es:");
			foreach (var alumnos in rta)
			{
				var alumnoProm = (AlumnoPromedio)alumnos;

				Console.WriteLine($"{alumnoProm.alumnoNombre} con promedio {alumnoProm.promedio}");
			}
			return rta;
		}

        public Dictionary<string, IEnumerable<AlumnoPromedio>> GetListaTopPromedio(int x)
        {
            var resp = new Dictionary<string, IEnumerable<AlumnoPromedio>>();
            var dicPromAlumPorAsignatura = GetPromeAlumPorAsignatura();

            foreach (var item in dicPromAlumPorAsignatura)
            {
                var dummy = (from ap in item.Value
                             orderby ap.promedio descending
                             select ap).Take(x);

                resp.Add(item.Key, dummy);
            }

            return resp;
        }

public List<AlumnoPromedio> GetTopPromedioAlumnosEnAsignatura(string nombreAsignatura, int cantidad = 5) {
	var respuesta = new List<AlumnoPromedio>();
	var diccionarioPromediosPorAsignatura = GetPromedioAlumnoPorAsignatura();

	var alumnosFiltradosPorCantidad = 
		(from promedios in diccionarioPromediosPorAsignatura
			where promedios.Key.Equals(nombreAsignatura)
				select promedios.Value)
				.First() // Como siempre devuelve una lista, por mas que haya un elemento hay que tomar .First()
				.OrderByDescending(promedioAlumno => promedioAlumno.promedio)
				.Take(cantidad);
				
	respuesta.AddRange(alumnosFiltradosPorCantidad);

	return respuesta;
}

Podría mejorarse bastante la performance, evitando llamar a `GetPromedioAlumnoPorAsignatura()` y haciendo todas las consultas previas filtrando por materia y nota desde el principio. Pero supuse que a motivos del ejercicio es suficiente, luego se puede mejorar la complejidad algorítmica en gran medida.

 public List<object> GetMejoresPromedioXAsignatura(string asignatura, int top = 10)
        {
            var rta = GetPromeAlumnnPorAsignatura();
            var asig = rta.GetValueOrDefault(asignatura).OrderByDescending(prom => ((AlumnoPromedio)prom).Promedio).Take(top);

            return asig.ToList();
        }```

public IEnumerable<object> GetMejoresPromxAsig(string asignatura, int cantidad = 5)
{
	var promAlumxAsig = GetPromAlumxAsig();
	var rta = promAlumxAsig.GetValueOrDefault(asignatura).OrderByDescending(prom => ((AlumnoPromedio) 
            prom).promedio).Take(cantidad);

	return rta;
}

 public Dictionary<string, IEnumerable<object>> TopPromedio(int top)
        {
            var rta = new Dictionary<string, IEnumerable<object>>();
            var dicEvalXAsig = GetDicEvaluaXAsig();

            foreach (var asigConEval in dicEvalXAsig)
            {
                var promsAlumn = (from eval in asigConEval.Value
                                  group eval by new
                                  {
                                      eval.Alumno.UniqueId,
                                      eval.Alumno.Nombre
                                  }
                            into grupoEvalsAlumno
                                  select new AlumnoPromedio
                                  {
                                      alumnoid = grupoEvalsAlumno.Key.UniqueId,
                                      alumnoNombre = grupoEvalsAlumno.Key.Nombre,
                                      //Por cada mimbro del volumen de datos estraer el valor nota (asigConEval.Value)
                                      promedio = grupoEvalsAlumno.Average(evaluacion => evaluacion.Nota)
                                  }).OrderByDescending(aluP => aluP.promedio).Take(top);

                rta.Add(asigConEval.Key, promsAlumn);
            }

            return rta;
        }```

public Dictionary<string, IEnumerable<PromedioAlumno>> GetTopAluPorAsig(int max) {
			var resp = new Dictionary<string, IEnumerable<PromedioAlumno>>();

			var dicPromAluPorAsig = GetPromAluPorAsig();
			foreach(var asig_aluProms in dicPromAluPorAsig) {
				var topProms = asig_aluProms.Value.Cast<PromedioAlumno>().OrderByDescending(e => e.promedio).Take(max);
				resp.Add(asig_aluProms.Key, topProms);
			}

			return resp;
		}

        foreach (var asig in listaPromXAsig)
        {

            var listaAlumnosTopAsignaturas = listaPromXAsig[asig.Key].OrderByDescending(alumnoPromedio => alumnoPromedio.promedio).Take(top);
            rta.Add(asig.Key, listaAlumnosTopAsignaturas);


        }
        return rta;
    }

 public IEnumerable<string> GetListSubject(out IEnumerable<Test> testList)
        {
            testList = GetListTest();

            return testList.Select(x => x.Subject.Name).Distinct();
        }

        public Dictionary<string, IEnumerable<Test>> GetTestsBySubject()
        {
            var dictionary = new Dictionary<string, IEnumerable<Test>>();
            var subjectsList = GetListSubject(out IEnumerable<Test> testsList);

            foreach (var subject in subjectsList)
            {
                var testListBySubject = testsList.Where(x => x.Subject.Name == subject);
                dictionary.Add(subject, testListBySubject);
            }
            return dictionary;
        }

        public Dictionary<string, IEnumerable<StudentAverange>> GetStudentAverageBySubject()
        {
            var studentAverageBySubjectDictionary = new Dictionary<string, IEnumerable<StudentAverange>>();
            var testDictionaryBySubject = GetTestsBySubject();

            foreach (var evalBySubject in testDictionaryBySubject)
            {

                var studentA = evalBySubject.Value.GroupBy(x => x.Student.Name);
                List<StudentAverange> studentAverange = new List<StudentAverange>();
                foreach (var studentScore in studentA)
                {
                    float average = studentScore.Average(x => x.Score);
                    string id = studentScore.First().Student.Id;
                    studentAverange.Add(new StudentAverange
                    {
                        StudentId = id,
                        StudentName = studentScore.Key,
                        Average = average
                    });
                }
                studentAverageBySubjectDictionary.Add(evalBySubject.Key, studentAverange);
            }
            return studentAverageBySubjectDictionary;
        }

        public Dictionary<string, IEnumerable<StudentAverange>> GetTopScoresBySubject(int numberOfTop = 1)
        {
            var topScoresList = new Dictionary<string, IEnumerable<StudentAverange>>();
            var testBySubjectAndStudent = GetStudentAverageBySubject();
            foreach (var evalBySubject in testBySubjectAndStudent)
            {
                var orderedList = evalBySubject.Value.OrderByDescending(x => x.Average)
                                                     .Take(numberOfTop);
                topScoresList.Add(evalBySubject.Key, orderedList);
            }
            return topScoresList;
        }

public Dictionary<string, IEnumerable<object>> GetTopPromedioAsignatura(int num, string asignatura)
        {
            var datos = GetPromedioAlumnoAsignatura();
            var dicTop = new Dictionary<string, IEnumerable<object>>();


            foreach (var item in datos)
            {
                string Asign = EliminarTildes(item.Key);
                if(Asign.ToUpper() == asignatura.ToUpper())
                {
                var top = (from datatop in item.Value
                            orderby ((AlumnoPromedio)datatop).Promedio descending
                            select datatop).Take(num);
                
                dicTop.Add(item.Key, top);
                }
            }

            return dicTop;

        }```

   public Dictionary<string, IEnumerable<object>> GetPromeAlumnXAsig(
            // out Dictionary<string, IEnumerable<object>> ListGen,
            // out Dictionary<string, IEnumerable<object>> ListTop,
            int top = 10
        )
        {
            var rta = new Dictionary<string, IEnumerable<object>>();
            var dicEvalXAsig = GetDicEvalXAsig();
            
            foreach (var asigConEval in dicEvalXAsig)
            {
                var promsAlum = from eval in asigConEval.Value
                            group eval by new{
                                eval.Alumno.UniqueId,
                                eval.Alumno.Nombre

                            } 
                            into grupoEvalsAlumno
                            select new AlumnoPromedio
                            {
                                alumnoId = grupoEvalsAlumno.Key.UniqueId, 
                                alumnoNombre = grupoEvalsAlumno.Key.Nombre, 
                                promedio = grupoEvalsAlumno.Average( evaluac => evaluac.Nota )
                            };
                rta.Add(asigConEval.Key, promsAlum.OrderByDescending((lp) => lp.promedio).Take(top));
            }
            return rta;
        }

	    listaPromXAsig = reporteador.GetPromeAlumnXAsig();
            Printer.WriteTitle("Lista De Alumnos Destacados");
            foreach (var asig in listaPromXAsig)
            {
                Printer.WriteTitle($"   {asig.Key}");
                var itm = 1;
                foreach (var Prom in asig.Value)
                {
                    switch (itm)
                    {
                        case 1:
                            WriteLine($"Primer Lugar {Prom} Felicitaciones!");
                            break;
                        case 2:
                            WriteLine($"Segundo Lugar {Prom} Felicitaciones!");
                            break;
                        case 3:
                            WriteLine($"Tercer Lugar {Prom} Felicitaciones!");
                            break;
                        default:
                            WriteLine(Prom);
                            break;
                    }
                    itm++;
                }
                
                
            }

class Program
{
    static void Main(string[] args)
    {
        // Instancia del reporte
        var reporte = new Reporte();

        // Invocación de los reportes
        var topMatematicas = reporte.GenerarReporte("Matemáticas", 5);
        var topCastellano = reporte.GenerarReporte("Castellano", 10);

        // Mostrar resultados
        Console.WriteLine(topMatematicas);
        Console.WriteLine(topCastellano);
    }
}

public Dictionary<string, IEnumerable<AlumnoPromedio>> GetPromedioAlumnosXAsignatura()
        {
            var rta = new Dictionary<string, IEnumerable<AlumnoPromedio>>();
            var dicEvalXAsig = GetDicEvalPorAsig();
            foreach (var asignaturaConEvaluaciones in dicEvalXAsig)
            {
                var promediosAlumnos = from eval in asignaturaConEvaluaciones.Value
                                       group eval by new { 
                                           eval.Alumno.UniqueId,
                                           eval.Alumno.Nombre }
                                        into grupoEvalsAlumno
                                       select new AlumnoPromedio { 
                                           alId = grupoEvalsAlumno.Key.UniqueId, 
                                           promedio = grupoEvalsAlumno.Average(evaluacion => evaluacion.Nota), 
                                           alNombre = grupoEvalsAlumno.Key.Nombre };
                rta.Add(asignaturaConEvaluaciones.Key,promediosAlumnos);
            }

            return rta;
        }

        public List<AlumnoPromedio> GetTopPromedioAlumnosXAsignatura(LlaveDiccionarioAsginaturas asignatura, int topCantidad = 5)
        {
            var rta = new List<AlumnoPromedio>();
            var dicPromediosAlumnosXasignatura = GetPromedioAlumnosXAsignatura();
            var soloListaPromediosAsignatura = dicPromediosAlumnosXasignatura[asignatura.ToString()];
            var topAlumnos = soloListaPromediosAsignatura.OrderByDescending(alumno => alumno.promedio).Take(topCantidad);
            rta.AddRange(topAlumnos);
            return rta;
        }

		public IEnumerable<object> GetMejorAlumnoPromedioPorAsignatura(string asignatura, int cantidad = 5)
		{

			var promAlumxAsig = GetPromedioAlumnPorAsignatura();
			var rta = promAlumxAsig.GetValueOrDefault(asignatura).OrderByDescending(prom => ((AlumnoPromedio)
					prom).promedio).Take(cantidad);

			Printer.WriteTitle($"En la materia {asignatura} el mejor promedio Top {cantidad} de estudiantes es:");
			foreach (var alumnos in rta)
			{
				var alumnoProm = (AlumnoPromedio)alumnos;

				Console.WriteLine($"{alumnoProm.alumnoNombre} con promedio {alumnoProm.promedio}");
			}
			return rta;
		}

Generación de Reportes con LINQ en C#

Introducción

Herencia y excepciones avanzadas en C#

Etapa 5 – POO reutilicemos nuestro código

Herencia para reutilizar código C#

Herencia y Polimorfismo en Programación Orientada a Objetos

Polimorfismo en Programación Orientada a Objetos

Casting en C#: cuándo funciona y cuándo falla

Conversiones seguras en C# con is y as

Sobrescribir ToString para depuración en C#

Etapa 6- Ajustes y funcionalidad

Interfaces en C#: contratos sin herencia múltiple

Uso de Interfaces y Polimorfismo en Visual Studio Code

Uso de Regiones en Visual Studio para Mejorar la Legibilidad del Código

Etapa 7 – Preparando información para nuestros reportes

Manejo Avanzado de Métodos y Parámetros en Programación

Manejo de Parámetros de Salida en Visual Studio Code

Sobrecarga de Métodos para Parámetros de Salida Opcionales

Optimización de Listas: Buenas Prácticas en C#

Dictionary: cómo funciona en C#

Diccionarios con polimorfismo en C#

Uso de Constantes y Enumeraciones para Optimizar Diccionarios en C#

Foreach anidado para diccionarios en C#

Depuración de diccionarios en C#

Parámetro opcional para controlar impresión en C#

Cómo usar switch en lugar de if/else

Números aleatorios y eventos en C#

Diccionarios y Refactoring en Programación Básica

Etapa 8 – Consultas

Cómo crear un reporteador en C sharp

Generación segura de reportes en sistemas de información

Construcción de reportes con LINQ en C#

Diccionario con evaluaciones por asignatura

Tipos anónimos en LINQ para reportes complejos

Cálculo del Promedio de Notas Agrupadas por Alumno y Asignatura

Creación de Tipos de Datos Personalizados en Programación Avanzada