Cursos Empresas Blog Live Conf Eventos Precios

0:002:09

Recursos

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.

Generación de Reportes con LINQ en C#

Curso de C# con .Net Core 2.1

Clase 31 / 35

Ver clases

Generación de Reportes con LINQ en C#

Curso de C# con .Net Core 2.1

Clase 31 de 35

Clase 31 / 35

Generación de Reportes con LINQ en C#

Curso de C# con .Net Core 2.1

Clase 31 / 35

Ver clases

Comentarios (99)99 comentarios

Omar Ismael Martínez Gómez

Hace 8 años

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

Hace 7 años

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

Luis Abdel Rangel Castro

Excelente!

Alexander Armúa Abregu

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!

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

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

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

Hace 4 años

Mi solucion del reto

Funcion para obtener un diccionario con el top de estudiantes.

Funcion para imprimir diccionarios.

Output

Guadalupe Giovanni Hernández Medina

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

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

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

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

Marvin Gonzalez

Dejo los enlaces del vídeo

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

Ginson Orellana

Hace 6 años

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

Hola @ginsorel

Cual es exactamente la pregunta?

rafael malanco velazquez

Lissett Paez

facil y sencillo... excelente aporte

Ariel Ricardo Delgadillo Terrazas

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

Hugo Marte

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

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

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

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

Hace un año

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.

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

fernando diez

Hace 3 años

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

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

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

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;
		}

Recursos

Resumen

Generación de Reportes con LINQ en C#

Generación de Reportes con LINQ en C#

Generación de Reportes con LINQ en C#

Progreso del curso

Introducción

Etapa 5 – POO reutilicemos nuestro código

Etapa 6- Ajustes y funcionalidad

Etapa 7 – Preparando información para nuestros reportes

Etapa 8 – Consultas

Etapa 9 – Creando una UI de Consola

Generación de Reportes con LINQ en C#

Generación de Reportes con LINQ en C#

Recursos

Resumen

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

¿Qué entradas y salidas exige el reporte?

¿Qué casos ejemplifica el instructor?

¿Qué habilidades y conceptos refuerzas con consultas Linq?

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

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

Comentarios

Recursos

Resumen

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

¿Qué entradas y salidas exige el reporte?

¿Qué casos ejemplifica el instructor?

¿Qué habilidades y conceptos refuerzas con consultas Linq?

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

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

Comentarios

Mi solucion del reto

Funcion para obtener un diccionario con el top de estudiantes.

Funcion para imprimir diccionarios.

Output