Generación de Evaluaciones Aleatorias con Notas Flotantes

Clase 30 de 32 • Fundamentos de C# con NET Core 2.1

Resumen

Domina la creación de datos de prueba con un reto clave: la carga aleatoria de evaluaciones. Pondrás en práctica lo aprendido sobre generación aleatoria para crear evaluaciones reales por curso, asignatura y alumno, con nombres al azar y notas flotantes entre 0.0 y 5.0. El objetivo es claro: aprender haciendo, con autonomía y creatividad.

¿En qué consiste el reto de carga aleatoria de evaluaciones?

Este desafío te pide generar datos coherentes y variados sin depender de soluciones únicas. Lo esencial es respetar las reglas del modelo: cursos con asignaturas y alumnos, y evaluaciones que pertenecen a ambos. No hay una única forma correcta: la clave es construir una solución funcional y comprensible.

¿Cuántas evaluaciones y con qué notas?

Cinco evaluaciones por asignatura, por cada alumno, en cada curso.
Nota aleatoria entre 0.0 y 5.0.
La nota debe ser decimal, no entera: usa un número flotante.
El nombre de la evaluación también debe ser generado al azar.

¿Qué significa ser creativo aquí?

Probar distintas formas de generar valores aleatorios.
Variar estrategias: pocas o muchas líneas, más o menos eficientes.
Priorizar soluciones claras y reproducibles.

¿Cómo deben relacionarse evaluaciones, alumnos y asignaturas?

Cada curso mantiene una lista de asignaturas y una lista de alumnos. Toda evaluación debe estar mapeada a un alumno existente y a una asignatura existente. Así garantizas consistencia en los datos de prueba y evitas evaluaciones “huérfanas”.

¿Qué mapeos son obligatorios?

Evaluación → Alumno: cada evaluación pertenece a un alumno creado previamente.
Evaluación → Asignatura: cada evaluación pertenece a una asignatura existente.
El curso provee el contexto con sus listas de alumnos y asignaturas.

¿Qué validar al generar la evaluación?

Pertenencia: alumno y asignatura deben existir en el curso.
Aleatoriedad: nombre y nota deben variar de forma realista.
Tipo de dato: la nota es flotante con decimales.

¿Qué habilidades y decisiones se trabajan en este reto?

Aquí aplicas lo visto sobre generación de contenido aleatorio y llevas más lejos tu criterio técnico. No hay una “solución perfecta”, pero sí decisiones informadas y razonadas.

¿Qué habilidades clave desarrollarás?

Generación de números aleatorios flotantes para notas decimalizadas.
Modelado de relaciones: curso, asignaturas, alumnos, evaluaciones.
Diseño con eficiencia variable: soluciones cortas o largas, simples o complejas.
Autonomía en investigación: busca cómo producir valores flotantes.
Colaboración: contrasta enfoques en la sección de comentarios.
Aprender haciendo: materializa lo aprendido con datos de prueba completos.

Te leo en comentarios: comparte tu enfoque, explica tus decisiones y compara resultados con tus compañeros para mejorar tu solución.

Daniela Muñoz Jiménez

student•

Yo agregué la variable "asignaturas" a la clase Alumno. Por que debe de haber 5 asignaturas por alumno, y es una lista.

public class Alumno  {
. . .
public List<Asignatura> Asignaturas{ get; set; }
. . .
}

Después agregué la variable "evaluacion" en la clase Asignaturas. Porque debe de haber 5 asignaturas por alumno, y cada asignatura por alumno solo lleva 1 evaluación, también una lista.

 public class Asignatura{
public double Evaluacion { get; set; }
}

En "class EscuelaEngine", el metodo CargarAsignaturas(), lo deje así. Ahí mismo genero la evaluación de forma aleatoria con NextDouble() * (5), para que sea de 0 - 5.

private List<Asignatura> CargarAsignaturas()
        {
           Random rnd = new Random();

             var listaAsignaturas = new List<Asignatura>(){
                            new Asignatura{Nombre="Matemáticas", Evaluacion=(rnd.NextDouble() * (5))} ,
                            new Asignatura{Nombre="Educación Física", Evaluacion=(rnd.NextDouble() * (5))},
                            new Asignatura{Nombre="Castellano", Evaluacion=(rnd.NextDouble() * (5))},
                            new Asignatura{Nombre="Ciencias Naturales", Evaluacion=(rnd.NextDouble() * (5))},
                             new Asignatura{Nombre="Historia", Evaluacion=(rnd.NextDouble() * (5 ))}
                             };
            return listaAsignaturas;
        }

Y en CargarCursos(), agrego otros for each, para llenar 5 asignaturas por alumno con una sola calificacion por materia - alumno. (En el reto no se menciona que las materias van aleatorias, solo las evaluaciones)

private void CargarCursos() {
. . .
Random rndAlumno = new Random();
            foreach(var curso in Escuela.Cursos)
            {
                int cantRandom = rndAlumno.Next(5, 20);
                curso.Alumnos = GenerarAlumnosAlAzar(cantRandom); //llena alumnos por curso

                   foreach(var alumno in curso.Alumnos){
                      alumno.Asignaturas = CargarAsignaturas();//llena asignaturas por alumno
                   }
            }
. . .
}

Rolando Mamani Salas

student•

Excelente !!

Bruno Martin Sendras

student•

Yo lo hice asi

        private void CargarEvaluaciones()
        {     
            int[] evaluacionNro = { 1, 2, 3, 4, 5 };

            // creo las evaluaciones            
            foreach (Curso curso in Escuela.Cursos)
            {

                var evaluaciones = from alumno in curso.Alumnos
                                   from asignatura in curso.Asignaturas
                                   from nro in evaluacionNro
                                   select new Evaluacion()
                                   {
                                       Nombre = $"\"Examen {nro}\"",
                                       Alumno = alumno,
                                       Asignatura = asignatura,
                                       Nota = (float)getRandomMark()
                                   };

                curso.Evaluaciones = evaluaciones.ToList();
            }
        }

        decimal getRandomMark()
        {
            Random random = new Random();
            decimal mark = random.Next(1, 50) / 10;
            // redondeamos a un decimal
            return decimal.Round(mark, 1);
        }

Bruno Martin Sendras

student•

Para el curso 501, y un alumno en particular, me quedan las siguientes evaluaciones.

501
Mireia Navarro Matematica "Examen 1" 3.2
Mireia Navarro Matematica "Examen 2" 1.8
Mireia Navarro Matematica "Examen 3" 3.8
Mireia Navarro Matematica "Examen 4" 1.8
Mireia Navarro Matematica "Examen 5" 4.4
Mireia Navarro Ed. Física "Examen 1" 1
Mireia Navarro Ed. Física "Examen 2" 0.8
Mireia Navarro Ed. Física "Examen 3" 1.3
Mireia Navarro Ed. Física "Examen 4" 4.4
Mireia Navarro Ed. Física "Examen 5" 2.1
Mireia Navarro Castellano "Examen 1" 0.2
Mireia Navarro Castellano "Examen 2" 0.9
Mireia Navarro Castellano "Examen 3" 3.1
Mireia Navarro Castellano "Examen 4" 3
Mireia Navarro Castellano "Examen 5" 1.5

Rolando Mamani Salas

student•

Bien hecho

Kevin Rafael Santacruz Burgos

student•

Yo agregue una lista de Evaluacionesdentro de Asignatura, mi solución:

private void CargarEvaluaciones()
        {
            foreach (var curso in Escuela.Cursos)
            {
                foreach (var alumno in curso.Alumnos)
                {
                    foreach (var asignatura in curso.Asignaturas)
                    {
                        for (int i = 0; i < 5; i++)
                        {
                            asignatura.Evaluaciones.Add(new Evaluaciones {
                            Alumno = alumno, Asignatura = asignatura, Nota = (float)Math.Round(GenerarNota(), 2, MidpointRounding.ToEven), Nombre = GenerarNombre(asignatura.Nombre, alumno.Nombre)
                            }); 
                        }
                    }
                }
            }
        }
        private string GenerarNombre(string asignatura, string alumno) {
            DateTime fecha = DateTime.Now;
            return $"{asignatura.ToUpper()}_{alumno}_{fecha.ToLongDateString()}";
}

private double GenerarNota() {
        Random rnd = new Random();
        return rnd.NextDouble() * 5;
}

Rolando Mamani Salas

student•

Buena solucion!

German Sandoval

student•

Ángel David Roque Ayala

student•

Agregar un for a la carga de evaluaciones y el método toString a la clase Evaluaciones le daría mas elegancia a tu código ya de por si elegante.

Joel Angel David Barrantes Palacios

student•

tener un bucle dentro de un bucle, esta bien, 3 bucles esta esta mas o menos tirando a mejor busca otra manera de implementar, hacer uso de 4 bucles es ser osado :-) y es mejor replantear lo que se esta haciendo.

Carlos Orjuela

student•

Reto comprendido: \n

Por cada Alumno de cada Curso, generar 5 evaluaciones por cada asignatura. La evaluación debe tener una nota entre 0.0 y 5.0 \n

 CargarEvaluaciones();

private void CargarEvaluaciones()
        {
            foreach (var curso in this.Escuela.Cursos)
            {
                curso.Evaluaciones = new List&lt;Evaluacion&gt;();
                
                foreach (var alumno in curso.Alumnos)
                {
                    foreach (var asignatura in curso.Asignaturas)
                    {
                        curso.Evaluaciones.AddRange(GenerarEvaluacion(alumno, asignatura));
                    }
                }                
            }
        }

private List&lt;Evaluacion&gt; GenerarEvaluacion(Alumno alumno, Asignatura asignatura)
        {
            string[] nombreEvaluacion = { &quot;Parcial 1&quot;, &quot;Parcial 2&quot;, &quot;Parcial 3&quot;, &quot;Parcial 4&quot;, &quot;Parcial 5&quot; };
            var listEvaluaciones = new List&lt;Evaluacion&gt;();

            foreach (var nota in nombreEvaluacion)
            {
                var evaluacion = new Evaluacion();
                evaluacion.Nombre = nota;
                evaluacion.Alumno = alumno;
                evaluacion.Asignatura = asignatura;

                evaluacion.Nota = (float)Math.Round((new Random().NextDouble() * (4.0 - 0.0 + 1) + 0.0), 1); /// (r.NextDouble() * (maximo - minimo + 1)) + minimo  

                listEvaluaciones.Add(evaluacion);
            }

            return listEvaluaciones;
        }

Resultado:

===============  FARID RICK TOLEDO  =================
Nombre: Parcial 1, Alumno: Farid Rick Toledo, Asignatura: Matemáticas, Nota: 0,8
Nombre: Parcial 2, Alumno: Farid Rick Toledo, Asignatura: Matemáticas, Nota: 1,5
Nombre: Parcial 3, Alumno: Farid Rick Toledo, Asignatura: Matemáticas, Nota: 1,7
Nombre: Parcial 4, Alumno: Farid Rick Toledo, Asignatura: Matemáticas, Nota: 4,1
Nombre: Parcial 5, Alumno: Farid Rick Toledo, Asignatura: Matemáticas, Nota: 1,4
Nombre: Parcial 1, Alumno: Farid Rick Toledo, Asignatura: Educación Física, Nota: 1,9
Nombre: Parcial 2, Alumno: Farid Rick Toledo, Asignatura: Educación Física, Nota: 0,7
Nombre: Parcial 3, Alumno: Farid Rick Toledo, Asignatura: Educación Física, Nota: 2
Nombre: Parcial 4, Alumno: Farid Rick Toledo, Asignatura: Educación Física, Nota: 1,1
Nombre: Parcial 5, Alumno: Farid Rick Toledo, Asignatura: Educación Física, Nota: 2,2
Nombre: Parcial 1, Alumno: Farid Rick Toledo, Asignatura: Castellano, Nota: 4,7
Nombre: Parcial 2, Alumno: Farid Rick Toledo, Asignatura: Castellano, Nota: 1,9
Nombre: Parcial 3, Alumno: Farid Rick Toledo, Asignatura: Castellano, Nota: 1,9
Nombre: Parcial 4, Alumno: Farid Rick Toledo, Asignatura: Castellano, Nota: 3,3
Nombre: Parcial 5, Alumno: Farid Rick Toledo, Asignatura: Castellano, Nota: 1,8
Nombre: Parcial 1, Alumno: Farid Rick Toledo, Asignatura: Ciencias Naturales, Nota: 2,6
Nombre: Parcial 2, Alumno: Farid Rick Toledo, Asignatura: Ciencias Naturales, Nota: 3,7
Nombre: Parcial 3, Alumno: Farid Rick Toledo, Asignatura: Ciencias Naturales, Nota: 3,7
Nombre: Parcial 4, Alumno: Farid Rick Toledo, Asignatura: Ciencias Naturales, Nota: 4,9
Nombre: Parcial 5, Alumno: Farid Rick Toledo, Asignatura: Ciencias Naturales, Nota: 2,2
===============  FARID RICK MADURO  =================
Nombre: Parcial 1, Alumno: Farid Rick Maduro, Asignatura: Matemáticas, Nota: 2,6
Nombre: Parcial 2, Alumno: Farid Rick Maduro, Asignatura: Matemáticas, Nota: 2,5
Nombre: Parcial 3, Alumno: Farid Rick Maduro, Asignatura: Matemáticas, Nota: 1
Nombre: Parcial 4, Alumno: Farid Rick Maduro, Asignatura: Matemáticas, Nota: 2,8
Nombre: Parcial 5, Alumno: Farid Rick Maduro, Asignatura: Matemáticas, Nota: 1,7
Nombre: Parcial 1, Alumno: Farid Rick Maduro, Asignatura: Educación Física, Nota: 3,7
Nombre: Parcial 2, Alumno: Farid Rick Maduro, Asignatura: Educación Física, Nota: 4,4
Nombre: Parcial 3, Alumno: Farid Rick Maduro, Asignatura: Educación Física, Nota: 0,3
Nombre: Parcial 4, Alumno: Farid Rick Maduro, Asignatura: Educación Física, Nota: 4,3
Nombre: Parcial 5, Alumno: Farid Rick Maduro, Asignatura: Educación Física, Nota: 2,9
Nombre: Parcial 1, Alumno: Farid Rick Maduro, Asignatura: Castellano, Nota: 2,6
Nombre: Parcial 2, Alumno: Farid Rick Maduro, Asignatura: Castellano, Nota: 3,3
Nombre: Parcial 3, Alumno: Farid Rick Maduro, Asignatura: Castellano, Nota: 4
Nombre: Parcial 4, Alumno: Farid Rick Maduro, Asignatura: Castellano, Nota: 2,6
Nombre: Parcial 5, Alumno: Farid Rick Maduro, Asignatura: Castellano, Nota: 0,6
Nombre: Parcial 1, Alumno: Farid Rick Maduro, Asignatura: Ciencias Naturales, Nota: 1
Nombre: Parcial 2, Alumno: Farid Rick Maduro, Asignatura: Ciencias Naturales, Nota: 3,7
Nombre: Parcial 3, Alumno: Farid Rick Maduro, Asignatura: Ciencias Naturales, Nota: 1,5
Nombre: Parcial 4, Alumno: Farid Rick Maduro, Asignatura: Ciencias Naturales, Nota: 0,3
Nombre: Parcial 5, Alumno: Farid Rick Maduro, Asignatura: Ciencias Naturales, Nota: 4,3

y continua la lista ....

Victor Carreto

student•

Muy bueno, pero por lo que investigue nadie sacaría 5.0

Miguel Peláez

student•

Agregue lista de Evaluaciones en Alumno y en la clase Evaluacion hay una propiedad de tipo Alumno y otra de tipo Asignatura.

        private void CargarEvaluaciones()
        {
            Random random = new Random();
            string[] Asignaturas = 
                Escuela.ListaCursos.FirstOrDefault().Asignaturas.Select(item => item.Nombre).ToArray();
            string[] NumeroEvaluacion = { "1", "2", "3", "4", "5" };

            var listaEvaluaciones = 
                    from n1 in Escuela.ListaCursos
                    from n2 in n1.Alumnos
                    from n3 in n1.Asignaturas
                    from n4 in NumeroEvaluacion
                    select new Evaluaciones
                    {
                        Nombre = $"Evaluacion de {n3.Nombre} # {n4}",
                        Asignatura = n3,
                        Alumno = n2,
                        Nota = (float)Math.Round((random.NextDouble() * 5), 1)
                    };

            foreach (var alumno in 
                Escuela.ListaCursos.SelectMany(item => item.Alumnos))
            {
                alumno.Evaluaciones = 
                    listaEvaluaciones.Where(item => item.Alumno.UniqueId == alumno.UniqueId).ToList();
            }                                    
        }

Daniel Ramirez Ramirez

student•

En Alumno.cs agregué

public List<Evaluaciones> Evaluaciones{ get; set; }

Resulta que .Next() nunca nos da el valor máximo, por eso puse 6 en los enteros y 10 en los decimales

private float GenerarNotaAlAzar()
{
    Random intNotaRnd = new Random();
    Random decNotaRnd = new Random();
    float nota = decNotaRnd.Next(0, 10);
    nota /= 10;
    nota += intNotaRnd.Next(0,6);
    if (nota > 5)
    {
        nota = (float)Math.Floor(nota);
    }
    return nota;
}
private void CargarEvaluaciones()
{
    foreach (var curso in Escuela.Cursos)
    {
        foreach (var alumno in curso.Alumnos)
        {
            var listaEvaluaciones = new List<Evaluaciones>();
            foreach (var asignatura in curso.Asignaturas)
            {
                listaEvaluaciones.Add(
                    new Evaluaciones
                    {
                        Nombre = $"Evaluacion {asignatura}",
                        Alumno = alumno,
                        Asignatura = asignatura,
                        Nota = GenerarNotaAlAzar()
                    }
                );
            }
            alumno.Evaluaciones = listaEvaluaciones;
        }
    }
}

Ricardo Pujol

student•

Además de agregar el siguiente atributo a la clase Alumno: public List<Evaluacion> Evaluaciones { get; set; } Así quedó mi código

Gabriel Ron Pérez

student•

Hola a todos, esta fue mi solución:

private void CargarEvaluaciones()
{

    foreach (var curso in Escuela.Cursos)
    {
        foreach (var alumno in curso.Alumnos)
        {
            alumno.Evaluaciones = new List<Evaluacion>();

            foreach (var asignatura in curso.Asignaturas)
            {
                for (int i = 0; i < 5; i++)
                {
                    Random rnd = new Random();
                    
                    var evaluacion = new Evaluacion
                    {
                        Nombre = $"Evaluación N°{i+1} de {asignatura.Nombre}",
                        Alumno = alumno,
                        Asignatura = asignatura,
                        Nota = (float)rnd.NextDouble() * 5
                    };

                    alumno.Evaluaciones.Add(evaluacion);
                }
            }
        }
    }
}

Espero les sea útil

Mono Jullier

student•

Yo hice algo muy parecido a esta solución pero la lista la agregué como propiedad del curso y no del alumno.

Sebastián Silva Hernández

student•

Hola tengo una duda una evaluacion ¿Que nombre llevaria? para saber como generarlo aleatoriamente

Héctor Eduardo López Carballo

student•

Hola!

Me podrías regalar más contexto sobre lo que quieres generar para poder ayudarte mejor?

Adriana Selena Tito Ilasaca

student•

Lo que hice fue adicionar una lista de tipo Test a la clase Student

 public List<Test> Tests { get; set; }

En la clase SchoolEngine, adicione dos metodos el primero que recorre la lista de cursos y de cada curso manda la lista de estudiantes y la lista de materias a otro metodo. Lo que hace el metodo GenerateTest es que genera 5 test de cada materia por alumno, lo almacena en la lista de listTest y luego lo asigna a la lista del alumno.

 private void AddTests()
        {
            foreach(var course in School.Courses)
            {
                GenerateTest(course.Subjects, course.Students, course.Name);
            }
        }

        private void GenerateTest(List<Subject> subjects, List<Student> students, string courseName)
        {
            Random random = new Random();
            foreach (var student in students)
            {
                List<Test> testList = new List<Test>();
                foreach (var subject in subjects)
                {
                    float score = (float)(5 * random.NextDouble());
                    string studentName = student.Name;
                    string testName = $"{subject.Name} - {courseName}";
                    testList.Add(new Test()
                    { 
                        Name = testName,
                        Score = score,
                        Student = student, 
                        Subject = subject
                    });
                }
                student.Tests = testList;
            }
        }

Emmanuel Guerra Sánchez

student•

Hice una sentencia con LINQ y una función para generar la nota:

Adicionalmente, cambie el **get ** de Nota en Evaluacion para mostrar dos decimales:

José Eduardo Vinagre de Dios

student•

        private void CargarEvaluaciones()
        {
            foreach (var curso in Escuela.Cursos)
            {
                float[] notes = { GenerarEvaluacion(), GenerarEvaluacion(), GenerarEvaluacion(), GenerarEvaluacion(), GenerarEvaluacion() };
                var evaluaciones = from al in curso.Alumnos
                                   from asig in curso.Asignaturas
                                   from n in notes
                                   select new Evaluaciones()
                                   {
                                       Alumno = al,
                                       Asignatura = asig,
                                       Nota = n
                                   };
                curso.Evaluaciones = evaluaciones.ToList();
            }
        }

        private float GenerarEvaluacion()
        {
            Random rnd = new Random();
            return (float)rnd.Next(0, 50) / (float)10;
        }

Sebastian Almiron

student•

Buenas,recorrí los cursos e hice un producto cartesiano entre los arreglos Curso.Alumnos, Curso.Asignatura y nombreEvaluacion, al finalizar cada curso guarde el listado en una variable y cuando conseguí todos los listados hice una recorrida al listado general y le asigne una nota luego lo retorne. El nombre lo genere concatenando un string con un Guid,

private List<Evaluaciones> GeneraEvaluaciones()
        {
            var listadoGeneral = new List<Evaluaciones>();
            foreach (var curso in Escuela.Cursos)
            {
                String[] nombreEvaluacion = { NombreExamen("Primer"), NombreExamen("Segundo"),
                    NombreExamen("Tercer"), NombreExamen("Cuarto"), NombreExamen("Quinto") };
                var listaEvaluaciones = from nom in nombreEvaluacion
                                        from alum in curso.Alumnos
                                        from asig in curso.Asignaturas
                                        select new Evaluaciones { Nombre=nom, Alumno=alum, Asignatura=asig };
                listadoGeneral.AddRange(listaEvaluaciones.ToList());
            }
            Random rnd = new Random();
            foreach (var examen in listadoGeneral)
            {
                float not = rnd.Next(1, 50);
                not /= 10;
                examen.Nota = not;
            }
            
            return listadoGeneral.OrderBy((al) => al.Alumno).ToList();
        }
        private String NombreExamen(string nom)
        {
            return nom+"-Examen-"+Guid.NewGuid().ToString().Substring(1, 5);
        }

Cristhian Coaquira

student•

private void CargarEvaluaciones()
        {
            Random random = new Random();
            string[] numeroEvaluaciones = {&quot;1&quot;, &quot;2&quot;, &quot;3&quot;, &quot;4&quot;, &quot;5&quot;};
            foreach (var curso in Escuela.Cursos)
            {
                var evaluaciones = from asignatura in curso.Asignaturas
                                    from alumno in curso.Alumnos
                                    from nroEvaluacion in numeroEvaluaciones
                                    select new Evaluaciones() { 
                                        Nombre = $&quot;{asignatura.Nombre} - {alumno.Nombre} - {nroEvaluacion}&quot;,
                                        Nota = generarNota(maximaNota: 5),
                                        Alumno = alumno,
                                        Asignatura = asignatura,
                                    };
                curso.Evaluaciones = evaluaciones.ToList();
            }
        }

        private float generarNota(int maximaNota = 10)
        {
            Random random = new Random();
            float nota = (float)(random.Next(0, maximaNota * 10)) / 10;
            return nota;
        }

Dennis Paul Franklin Pineda Licona

student•

Mi solución la subí a Github. https://github.com/dnniz/FundamentosNetCore

Aquí obtengo 5 nombres aleatorios de un conjunto de nombres.

Aquí adicionalmente valido que no exeda el maximo de la nota.

Cristian Rosales Hernandez

student•

En el video no quedó claro que se debe crear 5 evaluaciones por alumno, se dijo 5 evaluaciones por asignatura mas no se especificó que era 5 por alumno para que lo tengan en cuenta ✌🏼 (Vengo del futuro).

Francisco Torregrosa Ros

student•

Una Evaluación es medir el rendimiento de un alumno en una determinada asignatura por lo que es lógico asumir que es 5 por alumno.

Julio Pop Maquin

student•

Pueda ser que lo hice diferente pero según entendí las instrucciones había que generar 5 evaluaciones x asignatura lo cual es fue lo que hice, primero recorro por cada curso, por cada alumno y asignatura.

El resultado es: si existe 4 asignaturas entonces 4*5=20 en total por alumno que contiene 4 asignatura y cada asignatura tiene 5 evaluaciones.

Alguien lo entendió así o solo yo?

 private void CargarEvaluaciones()
        {
            foreach (var curso in Escuela.Cursos)
            {
                var rnd = new Random();
                List<Evaluacion> listaEvualuacion = new List<Evaluacion>();
                foreach (var alumno in curso.Alumnos)
                {
                    foreach (var asignatura in curso.Asignaturas)
                    {
                        for (int i = 1; i <= 5; i++)
                        {
                            float cantRandom = (float)(0.5 +(5.0 - 0.5) * rnd.NextDouble());
                            var eval = new Evaluacion()
                            {
                                Nombre = $" Evaluacion{i} {asignatura.Nombre}",
                                Alumno = alumno,
                                Asignatura = asignatura,
                                Nota = cantRandom
                            };
                            listaEvualuacion.Add(eval);
                        }
                    }
                }
                curso.Evaluaciones = listaEvualuacion; 
            }
        }

Leonardo Loayza

student•

A que se refiere carga aleatoria de evaluaciones? No estoy entendiendolo bien.

Octavio Vega

student•

En la Clase Evaluaiones cambie el Float Nota por List<float> Nota;

En la Clase Curso agrege la propiedad: public List<Evaluaciones> Evaluaciones { get; set; }

En la Clase EscuelaEngine en metodo CargarEvaluaciones cree un producto cartesiano para cada Curso con sus alumnos y susasiganturas, con un metodo para crear un nombre random y otro para asignar notas al azar entre 0.0 y 5.0

private List<Asignatura> CargarAsignaturas()
        {
           Random rnd = new Random();

             var listaAsignaturas = new List<Asignatura>(){
                            new Asignatura{Nombre="Matemáticas", Evaluacion=(rnd.NextDouble() * (5))} ,
                            new Asignatura{Nombre="Educación Física", Evaluacion=(rnd.NextDouble() * (5))},
                            new Asignatura{Nombre="Castellano", Evaluacion=(rnd.NextDouble() * (5))},
                            new Asignatura{Nombre="Ciencias Naturales", Evaluacion=(rnd.NextDouble() * (5))},
                             new Asignatura{Nombre="Historia", Evaluacion=(rnd.NextDouble() * (5 ))}
                             };
            return listaAsignaturas;
        }

private void CargarCursos() {
. . .
Random rndAlumno = new Random();
            foreach(var curso in Escuela.Cursos)
            {
                int cantRandom = rndAlumno.Next(5, 20);
                curso.Alumnos = GenerarAlumnosAlAzar(cantRandom); //llena alumnos por curso

                   foreach(var alumno in curso.Alumnos){
                      alumno.Asignaturas = CargarAsignaturas();//llena asignaturas por alumno
                   }
            }
. . .
}

        private void CargarEvaluaciones()
        {     
            int[] evaluacionNro = { 1, 2, 3, 4, 5 };

            // creo las evaluaciones            
            foreach (Curso curso in Escuela.Cursos)
            {

                var evaluaciones = from alumno in curso.Alumnos
                                   from asignatura in curso.Asignaturas
                                   from nro in evaluacionNro
                                   select new Evaluacion()
                                   {
                                       Nombre = $"\"Examen {nro}\"",
                                       Alumno = alumno,
                                       Asignatura = asignatura,
                                       Nota = (float)getRandomMark()
                                   };

                curso.Evaluaciones = evaluaciones.ToList();
            }
        }

        decimal getRandomMark()
        {
            Random random = new Random();
            decimal mark = random.Next(1, 50) / 10;
            // redondeamos a un decimal
            return decimal.Round(mark, 1);
        }

501
Mireia Navarro Matematica "Examen 1" 3.2
Mireia Navarro Matematica "Examen 2" 1.8
Mireia Navarro Matematica "Examen 3" 3.8
Mireia Navarro Matematica "Examen 4" 1.8
Mireia Navarro Matematica "Examen 5" 4.4
Mireia Navarro Ed. Física "Examen 1" 1
Mireia Navarro Ed. Física "Examen 2" 0.8
Mireia Navarro Ed. Física "Examen 3" 1.3
Mireia Navarro Ed. Física "Examen 4" 4.4
Mireia Navarro Ed. Física "Examen 5" 2.1
Mireia Navarro Castellano "Examen 1" 0.2
Mireia Navarro Castellano "Examen 2" 0.9
Mireia Navarro Castellano "Examen 3" 3.1
Mireia Navarro Castellano "Examen 4" 3
Mireia Navarro Castellano "Examen 5" 1.5

private void CargarEvaluaciones()
        {
            foreach (var curso in Escuela.Cursos)
            {
                foreach (var alumno in curso.Alumnos)
                {
                    foreach (var asignatura in curso.Asignaturas)
                    {
                        for (int i = 0; i < 5; i++)
                        {
                            asignatura.Evaluaciones.Add(new Evaluaciones {
                            Alumno = alumno, Asignatura = asignatura, Nota = (float)Math.Round(GenerarNota(), 2, MidpointRounding.ToEven), Nombre = GenerarNombre(asignatura.Nombre, alumno.Nombre)
                            }); 
                        }
                    }
                }
            }
        }
        private string GenerarNombre(string asignatura, string alumno) {
            DateTime fecha = DateTime.Now;
            return $"{asignatura.ToUpper()}_{alumno}_{fecha.ToLongDateString()}";
}

private double GenerarNota() {
        Random rnd = new Random();
        return rnd.NextDouble() * 5;
}

private void CargarEvaluaciones()
        {
            foreach (var curso in this.Escuela.Cursos)
            {
                curso.Evaluaciones = new List&lt;Evaluacion&gt;();
                
                foreach (var alumno in curso.Alumnos)
                {
                    foreach (var asignatura in curso.Asignaturas)
                    {
                        curso.Evaluaciones.AddRange(GenerarEvaluacion(alumno, asignatura));
                    }
                }                
            }
        }

private List&lt;Evaluacion&gt; GenerarEvaluacion(Alumno alumno, Asignatura asignatura)
        {
            string[] nombreEvaluacion = { &quot;Parcial 1&quot;, &quot;Parcial 2&quot;, &quot;Parcial 3&quot;, &quot;Parcial 4&quot;, &quot;Parcial 5&quot; };
            var listEvaluaciones = new List&lt;Evaluacion&gt;();

            foreach (var nota in nombreEvaluacion)
            {
                var evaluacion = new Evaluacion();
                evaluacion.Nombre = nota;
                evaluacion.Alumno = alumno;
                evaluacion.Asignatura = asignatura;

                evaluacion.Nota = (float)Math.Round((new Random().NextDouble() * (4.0 - 0.0 + 1) + 0.0), 1); /// (r.NextDouble() * (maximo - minimo + 1)) + minimo  

                listEvaluaciones.Add(evaluacion);
            }

            return listEvaluaciones;
        }

===============  FARID RICK TOLEDO  =================
Nombre: Parcial 1, Alumno: Farid Rick Toledo, Asignatura: Matemáticas, Nota: 0,8
Nombre: Parcial 2, Alumno: Farid Rick Toledo, Asignatura: Matemáticas, Nota: 1,5
Nombre: Parcial 3, Alumno: Farid Rick Toledo, Asignatura: Matemáticas, Nota: 1,7
Nombre: Parcial 4, Alumno: Farid Rick Toledo, Asignatura: Matemáticas, Nota: 4,1
Nombre: Parcial 5, Alumno: Farid Rick Toledo, Asignatura: Matemáticas, Nota: 1,4
Nombre: Parcial 1, Alumno: Farid Rick Toledo, Asignatura: Educación Física, Nota: 1,9
Nombre: Parcial 2, Alumno: Farid Rick Toledo, Asignatura: Educación Física, Nota: 0,7
Nombre: Parcial 3, Alumno: Farid Rick Toledo, Asignatura: Educación Física, Nota: 2
Nombre: Parcial 4, Alumno: Farid Rick Toledo, Asignatura: Educación Física, Nota: 1,1
Nombre: Parcial 5, Alumno: Farid Rick Toledo, Asignatura: Educación Física, Nota: 2,2
Nombre: Parcial 1, Alumno: Farid Rick Toledo, Asignatura: Castellano, Nota: 4,7
Nombre: Parcial 2, Alumno: Farid Rick Toledo, Asignatura: Castellano, Nota: 1,9
Nombre: Parcial 3, Alumno: Farid Rick Toledo, Asignatura: Castellano, Nota: 1,9
Nombre: Parcial 4, Alumno: Farid Rick Toledo, Asignatura: Castellano, Nota: 3,3
Nombre: Parcial 5, Alumno: Farid Rick Toledo, Asignatura: Castellano, Nota: 1,8
Nombre: Parcial 1, Alumno: Farid Rick Toledo, Asignatura: Ciencias Naturales, Nota: 2,6
Nombre: Parcial 2, Alumno: Farid Rick Toledo, Asignatura: Ciencias Naturales, Nota: 3,7
Nombre: Parcial 3, Alumno: Farid Rick Toledo, Asignatura: Ciencias Naturales, Nota: 3,7
Nombre: Parcial 4, Alumno: Farid Rick Toledo, Asignatura: Ciencias Naturales, Nota: 4,9
Nombre: Parcial 5, Alumno: Farid Rick Toledo, Asignatura: Ciencias Naturales, Nota: 2,2
===============  FARID RICK MADURO  =================
Nombre: Parcial 1, Alumno: Farid Rick Maduro, Asignatura: Matemáticas, Nota: 2,6
Nombre: Parcial 2, Alumno: Farid Rick Maduro, Asignatura: Matemáticas, Nota: 2,5
Nombre: Parcial 3, Alumno: Farid Rick Maduro, Asignatura: Matemáticas, Nota: 1
Nombre: Parcial 4, Alumno: Farid Rick Maduro, Asignatura: Matemáticas, Nota: 2,8
Nombre: Parcial 5, Alumno: Farid Rick Maduro, Asignatura: Matemáticas, Nota: 1,7
Nombre: Parcial 1, Alumno: Farid Rick Maduro, Asignatura: Educación Física, Nota: 3,7
Nombre: Parcial 2, Alumno: Farid Rick Maduro, Asignatura: Educación Física, Nota: 4,4
Nombre: Parcial 3, Alumno: Farid Rick Maduro, Asignatura: Educación Física, Nota: 0,3
Nombre: Parcial 4, Alumno: Farid Rick Maduro, Asignatura: Educación Física, Nota: 4,3
Nombre: Parcial 5, Alumno: Farid Rick Maduro, Asignatura: Educación Física, Nota: 2,9
Nombre: Parcial 1, Alumno: Farid Rick Maduro, Asignatura: Castellano, Nota: 2,6
Nombre: Parcial 2, Alumno: Farid Rick Maduro, Asignatura: Castellano, Nota: 3,3
Nombre: Parcial 3, Alumno: Farid Rick Maduro, Asignatura: Castellano, Nota: 4
Nombre: Parcial 4, Alumno: Farid Rick Maduro, Asignatura: Castellano, Nota: 2,6
Nombre: Parcial 5, Alumno: Farid Rick Maduro, Asignatura: Castellano, Nota: 0,6
Nombre: Parcial 1, Alumno: Farid Rick Maduro, Asignatura: Ciencias Naturales, Nota: 1
Nombre: Parcial 2, Alumno: Farid Rick Maduro, Asignatura: Ciencias Naturales, Nota: 3,7
Nombre: Parcial 3, Alumno: Farid Rick Maduro, Asignatura: Ciencias Naturales, Nota: 1,5
Nombre: Parcial 4, Alumno: Farid Rick Maduro, Asignatura: Ciencias Naturales, Nota: 0,3
Nombre: Parcial 5, Alumno: Farid Rick Maduro, Asignatura: Ciencias Naturales, Nota: 4,3

        private void CargarEvaluaciones()
        {
            Random random = new Random();
            string[] Asignaturas = 
                Escuela.ListaCursos.FirstOrDefault().Asignaturas.Select(item => item.Nombre).ToArray();
            string[] NumeroEvaluacion = { "1", "2", "3", "4", "5" };

            var listaEvaluaciones = 
                    from n1 in Escuela.ListaCursos
                    from n2 in n1.Alumnos
                    from n3 in n1.Asignaturas
                    from n4 in NumeroEvaluacion
                    select new Evaluaciones
                    {
                        Nombre = $"Evaluacion de {n3.Nombre} # {n4}",
                        Asignatura = n3,
                        Alumno = n2,
                        Nota = (float)Math.Round((random.NextDouble() * 5), 1)
                    };

            foreach (var alumno in 
                Escuela.ListaCursos.SelectMany(item => item.Alumnos))
            {
                alumno.Evaluaciones = 
                    listaEvaluaciones.Where(item => item.Alumno.UniqueId == alumno.UniqueId).ToList();
            }                                    
        }

private float GenerarNotaAlAzar()
{
    Random intNotaRnd = new Random();
    Random decNotaRnd = new Random();
    float nota = decNotaRnd.Next(0, 10);
    nota /= 10;
    nota += intNotaRnd.Next(0,6);
    if (nota > 5)
    {
        nota = (float)Math.Floor(nota);
    }
    return nota;
}
private void CargarEvaluaciones()
{
    foreach (var curso in Escuela.Cursos)
    {
        foreach (var alumno in curso.Alumnos)
        {
            var listaEvaluaciones = new List<Evaluaciones>();
            foreach (var asignatura in curso.Asignaturas)
            {
                listaEvaluaciones.Add(
                    new Evaluaciones
                    {
                        Nombre = $"Evaluacion {asignatura}",
                        Alumno = alumno,
                        Asignatura = asignatura,
                        Nota = GenerarNotaAlAzar()
                    }
                );
            }
            alumno.Evaluaciones = listaEvaluaciones;
        }
    }
}

private void CargarEvaluaciones()
{

    foreach (var curso in Escuela.Cursos)
    {
        foreach (var alumno in curso.Alumnos)
        {
            alumno.Evaluaciones = new List<Evaluacion>();

            foreach (var asignatura in curso.Asignaturas)
            {
                for (int i = 0; i < 5; i++)
                {
                    Random rnd = new Random();
                    
                    var evaluacion = new Evaluacion
                    {
                        Nombre = $"Evaluación N°{i+1} de {asignatura.Nombre}",
                        Alumno = alumno,
                        Asignatura = asignatura,
                        Nota = (float)rnd.NextDouble() * 5
                    };

                    alumno.Evaluaciones.Add(evaluacion);
                }
            }
        }
    }
}
        	

 private void AddTests()
        {
            foreach(var course in School.Courses)
            {
                GenerateTest(course.Subjects, course.Students, course.Name);
            }
        }

        private void GenerateTest(List<Subject> subjects, List<Student> students, string courseName)
        {
            Random random = new Random();
            foreach (var student in students)
            {
                List<Test> testList = new List<Test>();
                foreach (var subject in subjects)
                {
                    float score = (float)(5 * random.NextDouble());
                    string studentName = student.Name;
                    string testName = $"{subject.Name} - {courseName}";
                    testList.Add(new Test()
                    { 
                        Name = testName,
                        Score = score,
                        Student = student, 
                        Subject = subject
                    });
                }
                student.Tests = testList;
            }
        }

        private void CargarEvaluaciones()
        {
            foreach (var curso in Escuela.Cursos)
            {
                float[] notes = { GenerarEvaluacion(), GenerarEvaluacion(), GenerarEvaluacion(), GenerarEvaluacion(), GenerarEvaluacion() };
                var evaluaciones = from al in curso.Alumnos
                                   from asig in curso.Asignaturas
                                   from n in notes
                                   select new Evaluaciones()
                                   {
                                       Alumno = al,
                                       Asignatura = asig,
                                       Nota = n
                                   };
                curso.Evaluaciones = evaluaciones.ToList();
            }
        }

        private float GenerarEvaluacion()
        {
            Random rnd = new Random();
            return (float)rnd.Next(0, 50) / (float)10;
        }

private List<Evaluaciones> GeneraEvaluaciones()
        {
            var listadoGeneral = new List<Evaluaciones>();
            foreach (var curso in Escuela.Cursos)
            {
                String[] nombreEvaluacion = { NombreExamen("Primer"), NombreExamen("Segundo"),
                    NombreExamen("Tercer"), NombreExamen("Cuarto"), NombreExamen("Quinto") };
                var listaEvaluaciones = from nom in nombreEvaluacion
                                        from alum in curso.Alumnos
                                        from asig in curso.Asignaturas
                                        select new Evaluaciones { Nombre=nom, Alumno=alum, Asignatura=asig };
                listadoGeneral.AddRange(listaEvaluaciones.ToList());
            }
            Random rnd = new Random();
            foreach (var examen in listadoGeneral)
            {
                float not = rnd.Next(1, 50);
                not /= 10;
                examen.Nota = not;
            }
            
            return listadoGeneral.OrderBy((al) => al.Alumno).ToList();
        }
        private String NombreExamen(string nom)
        {
            return nom+"-Examen-"+Guid.NewGuid().ToString().Substring(1, 5);
        }

private void CargarEvaluaciones()
        {
            Random random = new Random();
            string[] numeroEvaluaciones = {&quot;1&quot;, &quot;2&quot;, &quot;3&quot;, &quot;4&quot;, &quot;5&quot;};
            foreach (var curso in Escuela.Cursos)
            {
                var evaluaciones = from asignatura in curso.Asignaturas
                                    from alumno in curso.Alumnos
                                    from nroEvaluacion in numeroEvaluaciones
                                    select new Evaluaciones() { 
                                        Nombre = $&quot;{asignatura.Nombre} - {alumno.Nombre} - {nroEvaluacion}&quot;,
                                        Nota = generarNota(maximaNota: 5),
                                        Alumno = alumno,
                                        Asignatura = asignatura,
                                    };
                curso.Evaluaciones = evaluaciones.ToList();
            }
        }

        private float generarNota(int maximaNota = 10)
        {
            Random random = new Random();
            float nota = (float)(random.Next(0, maximaNota * 10)) / 10;
            return nota;
        }

 private void CargarEvaluaciones()
        {
            foreach (var curso in Escuela.Cursos)
            {
                var rnd = new Random();
                List<Evaluacion> listaEvualuacion = new List<Evaluacion>();
                foreach (var alumno in curso.Alumnos)
                {
                    foreach (var asignatura in curso.Asignaturas)
                    {
                        for (int i = 1; i <= 5; i++)
                        {
                            float cantRandom = (float)(0.5 +(5.0 - 0.5) * rnd.NextDouble());
                            var eval = new Evaluacion()
                            {
                                Nombre = $" Evaluacion{i} {asignatura.Nombre}",
                                Alumno = alumno,
                                Asignatura = asignatura,
                                Nota = cantRandom
                            };
                            listaEvualuacion.Add(eval);
                        }
                    }
                }
                curso.Evaluaciones = listaEvualuacion; 
            }
        }

Generación de Evaluaciones Aleatorias con Notas Flotantes

Introducción al curso

Fundamentos de C-Sharp: Curso Introductorio con Proyecto Práctico

Instalación de Netcore SDK en Windows, Linux y OS X

Creación y Ejecución de Aplicaciones .NET Core en Consola

Instalación de Visual Studio Code en Windows, Linux y OSX

Configuración y Personalización de Visual Studio Code para C#

Historia y Evolución del Lenguaje C-Sharp

Versiones de C# y evolución del lenguaje

Clases y Objetos

Clases y Objetos en Programación Orientada a Objetos

Creación de Clases y Objetos en .NET con Visual Studio Code

Aprendamos con un proyecto

Proyecto Core Escuela: C# con propósito

Etapa 1 – Creando la escuela

Crea clase Escuela con propiedades en C#

Enumeraciones y sobreescritura de métodos en C#

Constructores con parámetros opcionales en C#

Etapa 2 – Creando Cursos para la escuela

Creación de Clases y Objetos en C# con Extensiones en Visual Studio Code

¿Qué es un arreglo?

Arreglos y Ciclos en C#: Creación y Recorrido con While

Bucles para recorrer arreglos en C#

Inicialización de arreglos y control de null en C#

Operadores if else y lógicos en C#

Operadores C# que programadores reales usan

Etapa 3 – Implementado colecciones para el manejo de cursos

Arreglos vs colecciones en C#

Uso de Colecciones en C#: Listas y Operaciones Básicas

Eliminación de Elementos en Listas Usando Criterios en C#

Simplifica colecciones con lambda y delegados

Etapa 4 – Refactorizando y cargando datos de prueba

Refactorización y Organización de Código en C#

Clases estáticas en C#: Uso y beneficios prácticos

Creación de Entidades: Alumno, Asignatura y Evaluación en C#

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

Generación de Alumnos Aleatorios en Cursos Educativos

El gran RETO

Generación de Evaluaciones Aleatorias con Notas Flotantes

Bucles anidados para crear evaluaciones masivas en C#

Resumen del Curso de Programación en C Sharp