A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

El gran reto

30/32
Recursos

En la clase anterior vimos como generar contenido aleatorio. Como reto debes generar la carga aleatoria de evaluaciones, cada asignatura debe tener 5 evaluaciones y cada alumno de cada curso debe tener evaluaciones. Las notas deben ir desde 0.0 a 5.0.

Aportes 99

Preguntas 1

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

Yo agregu茅 la variable 鈥渁signaturas鈥 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 鈥渆valuacion鈥 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 鈥渃lass 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
                   }
            }
. . .
}

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

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

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<Evaluacion>();
                
                foreach (var alumno in curso.Alumnos)
                {
                    foreach (var asignatura in curso.Asignaturas)
                    {
                        curso.Evaluaciones.AddRange(GenerarEvaluacion(alumno, asignatura));
                    }
                }                
            }
        }
private List<Evaluacion> GenerarEvaluacion(Alumno alumno, Asignatura asignatura)
        {
            string[] nombreEvaluacion = { "Parcial 1", "Parcial 2", "Parcial 3", "Parcial 4", "Parcial 5" };
            var listEvaluaciones = new List<Evaluacion>();

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

\n

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 鈥

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

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

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

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

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

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);
        }
private void CargarEvaluaciones()
        {
            Random random = new Random();
            string[] numeroEvaluaciones = {"1", "2", "3", "4", "5"};
            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 = $"{asignatura.Nombre} - {alumno.Nombre} - {nroEvaluacion}",
                                        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;
        }

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.

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).

Yo lo hice as铆鈥

En EscuelaEngine.cs

        public void Inicializar()
        {
            Escuela = new Escuela("Platzi", 1980,TiposEscuela.Secundaria, pais: "Venezuela", ciudad: "Valencia");

            CargarCursos();
            CargarAsignaturas();
            foreach (var c in Escuela.Cursos )
            {
                var ListaAlumnos = c.Alumnos;
                var ListaAsignaturas =c.Asignaturas;
               c.Evaluations = CargarEvaluaciones(ListaAlumnos, ListaAsignaturas);

            }   
            
        }

        private List<Evaluaciones> CargarEvaluaciones( List<Alumno> ListAlumno, List<Asignatura> ListAsignaturas)
        {
            Random rnd = new Random();
            var ListaEvaluaciones = new List<Evaluaciones>();
            Console.WriteLine($"Numero de Alumnos: {ListAlumno.Count} y Numero de Asignaturas: {ListAsignaturas.Count}");
            foreach (var Alumnin in ListAlumno)
            {
                foreach (var Materia in ListAsignaturas)
                {
                    ListaEvaluaciones.Add(new Evaluaciones() { Nombre = "Evaluacion1", Alumno = Alumnin, Asignatura = Materia, Nota = (float)((rnd.NextDouble()) * 5) });
                    ListaEvaluaciones.Add(new Evaluaciones() { Nombre = "Evaluacion2", Alumno = Alumnin, Asignatura = Materia, Nota = (float)((rnd.NextDouble()) * 5) });
                    ListaEvaluaciones.Add(new Evaluaciones() { Nombre = "Evaluacion3", Alumno = Alumnin, Asignatura = Materia, Nota = (float)((rnd.NextDouble()) * 5) });
                    ListaEvaluaciones.Add(new Evaluaciones() { Nombre = "Evaluacion4", Alumno = Alumnin, Asignatura = Materia, Nota = (float)((rnd.NextDouble()) * 5) });
                    ListaEvaluaciones.Add(new Evaluaciones() { Nombre = "Evaluacion5", Alumno = Alumnin, Asignatura = Materia, Nota = (float)((rnd.NextDouble()) * 5) });
                }
            }
            return ListaEvaluaciones;
        }

en Evaluaciones.cs

using System;

namespace CoreEscuela.Entidades
{
    public class Evaluaciones
    {
        public string UniqueId { get; private set; }
        public string Nombre { get; set; }

        public Alumno Alumno { get; set; }
        public Asignatura Asignatura { get; set; }

        public float Nota { get; set; }

        public Evaluaciones() => UniqueId = Guid.NewGuid().ToString();
    }
}

En la vida real los alumnos deben ser matriculados en las asignaturas que le correspondan segun el curso al que pertenezcan y de esa forma se deberan asignar notas en cada evaluacion que se genere para la asignatura por lo tanto cambie la aplicacion para que la jerarquia quede asi:
Escuela
鈥 Cursos
------ Asignaturas
--------- Alumnos
------------ Evaluaciones con Nota

private void CargarEvaluaciones()
        { 
            foreach (var curso in escuela.Cursos)
            {
                foreach (var asig in curso.Asignaturas)
                {
                    foreach (var alum in asig.Alumnos)
                    {
                        //notas random
                        Random nota = new Random();

                        var listaEvaluaciones = new List<Evaluaciones>(){
                            new Evaluaciones(){Nombre="Evaluacion 1", Nota=Math.Round((nota.Next(0,4) + nota.NextDouble()),2)},
                            new Evaluaciones(){Nombre="Evaluacion 2", Nota=Math.Round((nota.Next(0,4) + nota.NextDouble()),2)},
                            new Evaluaciones(){Nombre="Evaluacion 3", Nota=Math.Round((nota.Next(0,4) + nota.NextDouble()),2)},
                            new Evaluaciones(){Nombre="Evaluacion 4", Nota=Math.Round((nota.Next(0,4) + nota.NextDouble()),2)},
                            new Evaluaciones(){Nombre="Evaluacion 5", Nota=Math.Round((nota.Next(0,4) + nota.NextDouble()),2)}
                        };

                        alum.Evaluaciones=listaEvaluaciones;
                    }

                    ImprimirEvaluacionesNota(asig);                   
                }
            }
        }

Muy bien 馃槑

Yo lo hice as铆 cree un m茅todo de generar evaluaciones

private void GenerarEvaluacion(Curso curso, Alumno alumno,int CantidadEvaluacion = 5)
        {
            foreach (var asignatura in curso.Asignaturas)
            {
                if(asignatura == null) return;

                while(CantidadEvaluacion > 0)
                {
                    Evaluacion evaluacion = new Evaluacion()
                    {
                        Nombre = $"quiz {asignatura.Nombre} {CantidadEvaluacion}",
                        Asignatura = asignatura,
                        Alumno = alumno, 
                        Nota = (rnd.NextDouble() * 5 )
                    };
                    CantidadEvaluacion--;
                }
            }
        }     

Luego cuando se crea el inicializar se agrega por alumno

       public void Inicializar()
        {
            CargarEscuela();
            CargarAsignaturas();
            CargarEvaluaciones();
            
        }

        private void CargarEvaluaciones()
        {
            foreach (var curso in Escuela.Cursos)
            {
                foreach (var alumno in curso.Alumnos)
                {
                    GenerarEvaluacion(curso, alumno);
                }
            }
        }

Hola鈥 yo tome la decisi贸n de colocar las evaluaciones en el Alumno, luego me cre茅 2 funciones, para hacer que el n煤mero de evaluaciones sea param茅trico.

private void CargarEvaluaciones(){
            
            foreach(var curso in Escuela.Cursos)
            {
                foreach(var asignatura in curso.Asignaturas)
                {
                    foreach (var alumno in curso.Alumnos)
                    {
                        alumno.Evaluaciones.AddRange(GenerarEvaluacionesAzar(5,asignatura,alumno));
                    }
                }
            }
            
        }

        private List<Evaluaci贸n> GenerarEvaluacionesAzar(int cantidad, Asignatura asignatura,Alumno alumno)
        {
            List<Evaluaci贸n> evaluaciones = new List<Evaluaci贸n>();
            var rand = new Random(); 
            

            for (int i = 0; i < cantidad; i++)
            {
                Evaluaci贸n evaluaci贸n = new Evaluaci贸n{
                    Alumno = alumno,
                    Asignatura = asignatura,
                    Nombre = $"Evaluaci贸n {i+1}-{asignatura.Nombre}",
                    Nota = (float) new decimal(rand.NextDouble()) + rand.Next(0,5)
                };
                evaluaciones.Add(evaluacin);
                //Util.Printer.WriteTitle(evaluaci贸n.Nombre+" "+evaluaci贸n.Nota);
            }
            return evaluaciones;
        }

Implemente de esta manera la 鈥淐lase EscuelaEngine鈥

private void CargarEvaluaciones()
        {
            //Recorro los Cursos creados
            foreach (var curso in Escuela.Cursos)
            {
                //Recorro las Asignaturas creadas en el Curso
                foreach (var asignatura in curso.Asignaturas)
                {
                    //Recorro los Alumnos creados en el Curso
                    foreach (var alumno in curso.Alumnos)
                    {
                        alumno.Evaluaciones = new List<Evaluacion>();
                        alumno.Evaluaciones.AddRange(CargarEvaluacionAlAzar(alumno, asignatura));
                    }
                }
            }
        }
private List<Evaluacion> CargarEvaluacionAlAzar(Alumno alumno, Asignatura asignatura)
        {
            var listaEvaluaciones = new List<Evaluacion>();

            for (int i = 1; i <= 5; i++)
            {
                listaEvaluaciones.Add(new Evaluacion
                {
                    Alumno = alumno,
                    Asignatura = asignatura,
                    Nombre = $" Parcial: { i } ",
                    Nota = Nota()
                });
            }
            return listaEvaluaciones;
        }
private float Nota()
        {
            Random rdm = new Random();
            decimal nota = rdm.Next(0, 50) / Math.Round((decimal)10, 1);
            return (float)nota;
        }

Lo primero que hice fue agregarle una lista de evaluaciones a Curso.cs

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

y despues agregar en el m茅todo cargarEvaluaciones el siguiente c贸digo

   private void CargarEvaluaciones(int numEvaluacionAsignatura = 5)
        {
            foreach (var curso in Escuela.Cursos)
            {
                curso.Evaluaciones = new List<Evaluaciones>();
                foreach (var alumno in curso.Alumnos)
                {
                    foreach (var asignatura in curso.Asignaturas)
                    {
                        Random rnd = new Random();
                        for(var num = 1; num <= numEvaluacionAsignatura; num++){
                            decimal nota = (decimal)(rnd.Next(1, 50) / 10.0f);
                            curso.Evaluaciones.Add(new Evaluaciones(){
                                Alumno = alumno,
                                Asignatura = asignatura,
                                Nota = nota
                            });
                        }
                    }
                }
            }
        }

El flujo es el siguiente:cuando se cargan los cursos en EscuelaEngine, se cargan los alumnos en cada curso despu茅s se llamada a cargar asignaturas donde por cada curso de la escuela se itera cada alumno en cada alumno itere cada asignatura en las cual agregue las evaluaciones y despu茅s vuelvo a iterar por cada evaluaci贸n una nota (se hicieron cambios como poner asignaturas en cada alumno para iterar de esa manera), adicional cambie el orden de .Take() y OrderBy() por que me salieron alumnos con el mismo primer nombre.

public void inicializar()
            {
                    Escuela = new Escuela("Platzi M", 2020);  
                    Escuela.Ciudad = "Bogota";
                    Escuela.Pais = "Colombia";
                    Escuela.TipoEscuela = TiposEscuela.Primaria; 


                    cargarCursos();                                          
                    
                    cargarAsignaturas();
                    
                        
            }

        private List<Evaluacion> GenerarEvaluaciones()
        {
            string[] tema = { "Inicial", "Formativa", "Parcial", "Sumativa", "Global", "Previa", "Final" };        
            string[] nivel = { "Basica", "Quis", "Media", "Completa", "reiterativa"};

            var ListaEvaluaciones = from t in tema
                               from n in nivel                               
                               select new Evaluacion{Nombre=$"{t} {n}"};                               
            return ListaEvaluaciones.OrderBy((al)=> al.UniqID).Take(5).ToList();
        }

        private void cargarAsignaturas()
        {
            var Asignaturas = new List<Asignatura>()            
            {
                new Asignatura{Nombre = "Matematicas"},
                new Asignatura{Nombre = "Espa帽ol"},
                new Asignatura{Nombre = "Biologia"},
                new Asignatura{Nombre = "Fisica"},
                new Asignatura{Nombre = "Deporte"},
                new Asignatura{Nombre = "Programacion"}
            };
            
            
            foreach (var curso in Escuela.Cursos)
            {
                foreach (var al in curso.Alumnos)
                {
                    al.Asignaturas = Asignaturas;
                    foreach (var asignatura in al.Asignaturas)
                    {
                        asignatura.Evaluaciones = GenerarEvaluaciones();
                        foreach (var evaluacion in asignatura.Evaluaciones)
                        {
                            Random cantidad = new Random();
                            double cantidadrandom = (cantidad.NextDouble() + cantidad.Next(1,5));
                            evaluacion.Nota = Math.Round(cantidadrandom,1);
                        }
                    }
                }
            }
                
            
        }

        private List<Alumno> GenerarAlumnos(int cantidad)
        {
            string[] nombre1 = { "Alba", "Felipa", "Eusebio", "Farid", "Donald", "Alvaro", "Nicol谩s" };
            string[] apellido1 = { "Ruiz", "Sarmiento", "Uribe", "Maduro", "Trump", "Toledo", "Herrera" };
            string[] nombre2 = { "Freddy", "Anabel", "Rick", "Murty", "Silvana", "Diomedes", "Nicomedes", "Teodoro" };

            var listaAlumnos = from n1 in nombre1
                               from n2 in nombre2
                               from a1 in apellido1
                               select new Alumno{Nombre=$"{n1} {n2} {a1}"};                
            return listaAlumnos.OrderBy((al)=> al.UniqID).Take(cantidad).ToList();
            // i did change the place of the order .Take() due to the list had only one firstname
        }

        private void cargarCursos()
        {
            Escuela.Cursos = new List<Curso>()
                            {
                                new Curso(){Nombre = "101", Jornada = TiposJornada.Tarde},
                                new Curso(){Nombre = "201", Jornada = TiposJornada.Tarde },
                                new Curso(){Nombre = "301", Jornada = TiposJornada.Tarde }
                            };

            
                    foreach (var item in Escuela.Cursos)
                    {
                        Random cantidad = new Random();
                        int cantidadrandom = cantidad.Next(30, 50);
                        item.Alumnos = GenerarAlumnos(cantidadrandom);
                    }

        }

        public override string ToString()
        {
            return $"{Escuela.Name}\n{Escuela.A帽oDeCreacion}\n{Escuela.Ciudad}\n{Escuela.Pais}\n";
        }

 

        }

}```

resultado : 

Alba Murty Trump

===========
Matematicas

Sumativa Basica Nota 2,4
Inicial Basica Nota 1,2
Previa Media Nota 4,8
Inicial reiterativa Nota 3,4
Inicial Quis Nota 2,8

Espa帽ol

Previa Completa Nota 2,7
Sumativa Quis Nota 3,3
Global Media Nota 4,8
Inicial reiterativa Nota 3,2
Sumativa reiterativa Nota 2,1

Biologia

Inicial Completa Nota 1,3
Formativa Quis Nota 4,8
Parcial Media Nota 3
Sumativa Media Nota 2,1
Global Media Nota 5

Fisica

Previa Completa Nota 3
Sumativa Quis Nota 3,5
Inicial Completa Nota 2,5
Inicial Quis Nota 4,1
Sumativa Basica Nota 4,1

Deporte

Inicial Completa Nota 2,2
Inicial Quis Nota 1,3
Inicial reiterativa Nota 1,1
Final Completa Nota 3,9
Global Quis Nota 1,3

Programacion

Global Completa Nota 3,5
Inicial Media Nota 4,4
Final reiterativa Nota 2,5
Parcial Completa Nota 3,7
Sumativa Basica Nota 1,3```

using System;
using System.Collections.Generic;
using System.Linq;
using CoreEscuela.Entidades;

namespace CoreEscuela
{
public class EscuelaEngine
{
// public List<Evaluaciones> Evaluaciones{ get; set;}

// public List<Evaluaciones> Evaluaciones {get; set;}
public Escuela Escuela { get; set; }
public EscuelaEngine()
{

    }


    public void Inicializar()
    {

        Escuela = new Escuela("Platzy Academy", 2012,
        TiposEcuela.Primaria, ciudad: "Bogota", pais: "Colombia");
        CargarCursos();
        CargarAsignaturas();
        CaragarEvaluaciones();

    }

    private void CargarCursos()
    {
        Escuela.Cursos = new List<Curso>(){
            new Curso() { Nombre = "101", Jornada = TiposJornada.Ma帽ana},
            new Curso() { Nombre = "201", Jornada = TiposJornada.Ma帽ana},
            new Curso { Nombre = "301", Jornada = TiposJornada.Ma帽ana},
            new Curso { Nombre = "401", Jornada = TiposJornada.Tarde},
            new Curso { Nombre = "501", Jornada = TiposJornada.Tarde},
        };

        Random rnd = new Random();
        foreach (var c in Escuela.Cursos)
        {
            int cantRandom = rnd.Next(5, 20);
            c.Alumnos = GenerarAlumnoALAzar(cantRandom);

        }

    }

    private void CargarAsignaturas()
    {
        foreach (var curso in Escuela.Cursos)
        {
            var listaAsignaturas = new List<Asignatura>(){
                new Asignatura{Nombre="Matematicas" },
                new Asignatura{Nombre="Educacion Fisica" },
                new Asignatura{Nombre="Castellano" },
                new Asignatura{Nombre="Ciencias Naturales" }
            };
            curso.Asignaturas = listaAsignaturas;
        }
    }

    private void CaragarEvaluaciones()
    {

        //    List<Evaluaciones> = new Evaluaciones();

        var listaEvaluaciones = new List<Evaluaciones>();

        foreach (var cursos in Escuela.Cursos)
        {
            foreach (var alumnosLoad in cursos.Alumnos)
            {
                foreach (var asigturasLoad in cursos.Asignaturas)
                {
                    for (int i = 0; i < 5; i++)
                    {
                        var evaluacionesAlumnos = new Evaluaciones();
                        evaluacionesAlumnos.Nombre = $"parcial {i}.";
                        evaluacionesAlumnos.Alumno = alumnosLoad;
                        evaluacionesAlumnos.Asignatura = asigturasLoad;
                        Random rndNota = new Random();
                        Random rndNotaDecimal = new Random();
                        double valor = rndNotaDecimal.NextDouble();
                        float nota = rndNota.Next(2, 5) + (float)valor;
                        evaluacionesAlumnos.Nota = nota;
                        listaEvaluaciones.Add(evaluacionesAlumnos);
                                                    
                    }
                }
            }

        }
    }


    private List<Alumno> GenerarAlumnoALAzar(int cantidad)
    {
        string[] nombre1 = { "Alba", "Felipa", "Eusebio", "Farid", "Donald", "Alvaro", "Nicol谩s" };
        string[] apellido1 = { "Ruiz", "Sarmiento", "Uribe", "Maduro", "Trump", "Toledo", "Herrera" };
        string[] nombre2 = { "Freddy", "Anabel", "Rick", "Murty", "Silvana", "Diomedes", "Nicomedes", "Teodoro" };

        var listaAlumnos = from n1 in nombre1
                           from n2 in nombre2
                           from a1 in apellido1
                           select new Alumno { Nombre = $"{n1} {n2} {a1}" };
        return listaAlumnos.OrderBy((a1) => a1.UniqueId).Take(cantidad).ToList();

    }

}

}

Como la class Evaluaciones, no tenia referencia de ninguna parte (Nadie conoc铆a a Evaluaciones pero Evaluaciones si conoc铆a a Alumno y Asignatura) modifique un poco el c贸digo para que Alumno tenga una lista de Evaluaciones.
Les dejo mi solucion:

Alumno.cs

using System;
using System.Collections.Generic;

namespace CoreEscuela.Entidades
{
    public class Alumno
    {
        public string UniqueId { get; private set; }
        public string Nombre { get; set; }
        public List<Evaluaciones> Evaluaciones { get; set; }

        public Alumno() {
            UniqueId = Guid.NewGuid().ToString();
            Evaluaciones = new List<Evaluaciones>();
        } 
    }
}

EscuelaEngine.cs

private void CargarEvaluaciones()
{
    foreach (Curso curso in Escuela.Cursos)
    {
        foreach (Alumno alumno in curso.Alumnos)
            {
                foreach (Asignatura asignatura in curso.Asignaturas)
                {
                    for (int i = 0; i < 5; i++)
                    {
                        alumno.Evaluaciones.Add(new Evaluaciones(){
                        Nombre = generarNombreAleatorioAsignatura(asignatura),
                        Alumno = alumno,
                        Asignatura = asignatura,
                        Nota = generarNumeroAleatorio(0.0f, 5.0f)
                    });
                }
            }
        }
    }
}

private string generarNombreAleatorioAsignatura(Asignatura asig) {
    return $"{asig.Nombre} - {Guid.NewGuid().ToString()}";
}    

private float generarNumeroAleatorio(float min, float max)
{
    return (float) new Random().NextDouble() * (max - min) + min;
}

De este modo, ahora se podr铆a modificar a la class Escuela para que al hacer un .ToString() Muestre sus Cursos y por cada uno sus Alumnos y por cada uno sus Asignaturas

Hola comparto mi soluci贸n del Reto,
La parte de mapear la evaluaci贸n con el alumno y la asignatura la hice con foreach anidados
驴Creen que haya una mejor opci贸n?

Archivo: Evaluaciones.cs

    public class Evaluaciones
    {        
        public string Nombre { get; set; }

        public string UniqueId { get; private set; }

        public Evaluaciones() => UniqueId = Guid.NewGuid().ToString();

        public double Nota { get; set; }

        public string AlumnoUniqueId { get; set; }

        public string AsignaturaUniqueId { get; set; }
    }


Archivo: EscuelaEngine.cs

        private void CargaEvaluaciones()
        {
            foreach (var curso in Escuela.Cursos)
            {
                foreach (Alumno al in curso.Alumnos)
                {


                    foreach (Asignatura a in curso.Asignaturas)
                    {

                        List<Evaluaciones> lstEval = GenerarEvaluacionesAlAzar(al.UniqueId, a.UniqueId);
                        a.ListEvaluaciones = lstEval;
                    }
                }
            }
        }

        private static List<Evaluaciones>  GenerarEvaluacionesAlAzar(string uniqueIdAlum, string uniqueIdAsig)
        {
            List<Evaluaciones> lstE = new List<Evaluaciones>();
            
            for (int i = 1; i<=5; i++)
            {
                Evaluaciones eval = new Evaluaciones();
                eval.AlumnoUniqueId = uniqueIdAlum;
                eval.AsignaturaUniqueId = uniqueIdAsig;
                eval.Nombre = "Nombre_"+GenerarNombreEvaluacion();
                eval.Nota =GetRandomNota(0.0, 5.0);

                lstE.Add(eval);
            }
            return lstE;


        }

        private static string GenerarNombreEvaluacion()
        {
            Random NombreEval = new Random();
            string sCadena = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
            int longitud = sCadena.Length;
            char cletra;
            int nlongitud = 5;
            string sNuevacadena = string.Empty;
            for (int i = 0; i < nlongitud; i++)
            {
                cletra = sCadena[NombreEval.Next(longitud)];
                sNuevacadena += cletra.ToString();
            }
            return sNuevacadena;
        }

        private static double GetRandomNota(double minimum, double maximum)
        {
            Random random = new Random();
            double nota = random.NextDouble() * (maximum - minimum) + minimum;
            nota = Math.Truncate(nota * 10) / 10;
            return nota;
        }

        private void ImprimirEvaluaciones()
        {
            foreach (var curso in Escuela.Cursos)
            {
                foreach(Asignatura a in curso.Asignaturas)
                {
                    WriteLine($"Asignatura {a.Nombre} ");

                    foreach (Evaluaciones e in a.ListEvaluaciones)
                    {
                        WriteLine($"Evaluaci贸n: {e.Nombre} Nota: {e.Nota} UniqIdAlum: {e.AlumnoUniqueId} UniqIdAsig: {e.AsignaturaUniqueId}");
                    }
                }
            }            
        }

Mi soluci贸n:
Archivo Evaluacion.cs

namespace CoreEscuela.Entidades
{
    public class Evaluacion
    {
        public string UniqueId { get; private set; }
        public string Nombre { get; set; }
        public Alumno Alumno { get; set; }
        public Asignatura Asignatura  { get; set; }
        public float Nota { get; set; }

        public Evaluacion() => UniqueId = Guid.NewGuid().ToString();
    }
}

Como no hab铆a ninguna clase que guarde los ex谩menes entonces los puse en Curso, y tambi茅n modifique el constructor:

public Curso() 
{
    UniqueId = Guid.NewGuid().ToString();
    Asignaturas = new List<Asignatura>();
    Alumnos = new List<Alumno>();
    Evaluaciones = new List<Evaluacion>();
}
public List<Evaluacion> Evaluaciones{ get; set; }

Y por ultimo el metodo cargar evaluaciones en el archivo EscuelaEngine.cs:

private void CargarEvaluaciones()
{
    var rnd = new Random();
    foreach (var curso in Escuela.Cursos)
    {
        foreach (var asignatura in curso.Asignaturas)
        {
            foreach (var alumno in curso.Alumnos)
            {
// Creo la lista de evaluaciones para esta asignatura y est茅 estudiante y la agrego a la lista de evaluaciones de este curso
                var lista = new List<Evaluacion>();
                for (int i = 0; i < 5; i++)
                {
                    lista.Add(new Evaluacion(){
// Para la nota genero un numero entre 0 y 500, lo convierto al flotante y luego lo divido entre 100 para obtener un flotante con 2 decimales, la cantidad de decimales que manejan en las escuelas
                        Nota = rnd.Next(0, 500) / 100,
                        Alumno = alumno,
                        Asignatura = asignatura,
                        Nombre = $"Evaluacion de {asignatura.Nombre} #{i+1}"
                    });
                }
                curso.Evaluaciones.AddRange(lista);
            }
        }
    }
}

Hola, les comparto mi soluci贸n

Esta es mi clase Estudiante

using System;
using System.Collections.Generic;

namespace CoreSchool.Entities
{
    public class Student
    {
        public string Id { get; set; }
        public string Name { get; set; }
        public List<Test> Tests { get; set; }

        public Student()
        {
            Id = Guid.NewGuid().ToString();
        }
    }
}

Esta es mi clase RandomUtil

using System;

namespace CoreSchool.Util
{
    public static class RandomUtil
    {

        public static double NextDouble(this Random RandGenerator, double MinValue, double MaxValue)
        {
            return RandGenerator.NextDouble() * (MaxValue - MinValue) + MinValue;
        }
        
    }
}

Estos son los m茅todos para generar las evaluaciones


        private void LoadTests()
        {
            Random random = new Random();

            foreach (var course in School.Courses)
            {
                
                foreach (var student in course.Students)
                {
                    student.Tests = new List<Test>();

                    foreach (var subject in course.Subjects)
                    {
                        for (int i = 0; i < 5; i++)
                        {
                            float Note = float.Parse(random.NextDouble(0,5).ToString("0.##"));    
                            student.Tests.Add(
                                new Test{
                                    Name = GenerateTestRandomName(course, student, subject, i+1),
                                    Note = Note,
                                    Subject = subject,
                                    Student = student
                                }
                            );
                        }
                    }
                    
                }
            }
        }

        private string GenerateTestRandomName(Course course, Student student, Subject subject, int count)
        {
            return $"test-{course.Name}-{student.Name}-{subject.Name}-0"+count;
        }


Hola amigos!

Esta fue la funci贸n con la cu谩l genere la calificaci贸n aleatoria:

 public static double GradeTest(int min = 1, int max = 5)
        {
            Random rnd = new Random();
            double dec = rnd.NextDouble();
            int num = rnd.Next(min, max);
            return ((double)num + dec);

        }```

El m茅todo de calificaci贸n lo deje con una variable de m谩ximo ajustable puesto que en ocasiones hay profesores que dicen la famosa rela de "Le califico sobre cuatro" jejeje.

Cada vez que creaba un nuevo test en el constructor generaba su respectiva calificaci贸n.

public class Test
{
public Guid ID { get; set; }
public string courseName { get; set; }
public Subject subject { get; set; }
public Student student { get; set; }
public double score { get; set; }

    public Test(string courseName, Subject sub, Student st, int maxScore = 5)
    {
        this.ID = Guid.NewGuid();
        this.courseName = courseName;
        this.subject = sub;
        this.student = st;
        this.score = Grader.GradeTest(max: maxScore);
    }
}```

Cu谩ndo estaba recorriendo cada curso para agregar la lista de estudiantes aproveche para de una vez generar sus respecticas calificaciones:

  foreach (var course in school.courses)
            {
                int len = rnd.Next(5, 20);
                course.ListStudents.AddRange(initStudents(len));
                scores.AddRange(generateGrades(course));
            }

            Printer.printScores(scores); ```

 y por 煤ltimo gener茅 un m茅todo en la clase Printer para que intentara generar una especie de tabla:

public static void printScores(List<Test> scores){
        
        WriteLine("| UNIQUEIDENTIFIER | COURSE | SUBJECT | STUDENT NAME | SCORE |");
        foreach (var score in scores)
        {
            var infoRow = $"| {score.ID} | {score.courseName} | {score.subject.Name} | {score.student.Name} | {score.score.ToString("0.0")} |"   ;
            WriteLine(infoRow);
        }
        PrintLine(50,'#');
    }```

En mi caso tuvo m谩s sentido que agregara un ARREGLO de Evaluaciones de tipo double, porque siempre la cantidad de ellas es fija (o sea 5).

Adem谩s decid铆 usar para poder combinar los alumnos que ya tenemos con las asignaturas que existen con un producto cartesiano mediante linq, como cuando hicimos las combinatorias de los nombres con los apellidos. Y adem谩s agregu茅 una funci贸n que realizara la Generaci贸n de las notas al azar

public class Asignatura
    {
        public string UniqueId { get; private set; }
        public string Nombre { get; set; }
        public double[] Evaluaciones = new double[5];  

        public Asignatura() => UniqueId = Guid.NewGuid().ToString();
    }

private void CargarEvaluaciones()
        {
            foreach (var curso in Escuela.Cursos)
            {
                var calificaciones = from alum in curso.Alumnos
                                     from asig in curso.Asignaturas
                                     select new
                                     {
                                         alumno = alum,
                                         asignatura = asig,
                                     };

                int length = 5;

                foreach (var calif in calificaciones)
                {
                    for (int i = 0; i < length; i++)
                    {
                        calif.asignatura.Evaluaciones[i] = GenerarNotaAlAzar();
                    }
                }
            }
        }

        private double GenerarNotaAlAzar()
        {
            var calif = (new Random()).NextDouble() * 10;
            return Math.Round(calif > 5d ? calif / 2d : calif, 1);
        }

Esta fue mi manera de resolver el reto, puse evaluaciones en asignatura y cree una clase public static class CalificacionAzar en donde se encuentra un metodo que calcula la nota de la evaluacion.

private void CargarEvaluaciones()
        {
           foreach (var i in Escuela.Cursos)
            {
                foreach (var o in i.Alumnos)
                {
                    foreach (var p in i.Asignaturas)
                    {
                        for (int j = 0; j < (i.Asignaturas.Count*5); j++)
                        {
                            p.Evaluaciones.Add(new Evaluacion
                            {
                                Alumno = o,
                                Nota = CalificacionAzar.CargarNotaAzar(0,50)
                            });
                        }
                    }
                }
            }
        }```

Aqu铆 les dejo mi soluci贸n!

Saludos!

Excelente!

Dificil, no me queda claro

yo cree la clase evaluaci贸n con la siguiente estructura

using System;


namespace CorEscuela.Entidades
{
    public class Evaluacin
    {
        public Asignatura asignatura { get; set; }
        public double nota { get; set; }

        public Evaluaci贸n(Asignatura asignatura, double nota) => (this.asignatura, this.nota) = (asignatura, nota);

    }
}```

y cree el siguiente m茅todo para generar el aleatorio de las notas



private void CargarEvaluaciones()
{
Random e= new Random();
foreach (var curso in escuela.Cursos)
{
foreach(var Alumno in curso.Alumnos){
var evaluaciones=curso.Asignaturas.Select(x=>(new Evaluaci贸n(x,(5*e.NextDouble()))))as IEnumerable<Evaluaci贸n>;
Alumno.Evaluaci贸nes=evaluaciones.ToList();
}
}
}

Dejo mi repo, con la soluci贸n que implemente https://github.com/NicolasTicona/escuela-console

private List<double> getRandomValue(int cant){
var rnd = new Random();
var values = new List<double>();
for(int i = 0; i<cant; i++){
values.Add(rnd.Next(0,5) - rnd.NextDouble());
}
return values;
}

Buenas clases

Yo lo hice casi igual que @brunosendras y me genera la data pero los alumnos generados no son aleatorios

Los alumnos autogenerados siempre son los mismos una y otra vez "reduje el n煤mero de alumnos a 2 y el numero de cursos tambi茅n a dos"
Nota: El UniqueId varia pero los nombres no.

============================
| BIENVENIDOS A LA ESCUELA |
============================
========================
| Cursos de la Escuela |
========================
=================================================================
| Curso: 101, Id de curso: 220b5918-ad18-45be-96d2-c2a4253727b1 |
=================================================================
  Id:cf2fa0a9-b09e-4b83-a6dc-3a794bc271d7, Alumno:Antonio Ernesto Flores, Nombre:Matem谩ticas Eval 1, Asignatura:Matem谩ticas, Nota: 0.7491391
  Id:cf2fa0a9-b09e-4b83-a6dc-3a794bc271d7, Alumno:Antonio Ernesto Flores, Nombre:Educaci贸n f铆sica Eval 1, Asignatura:Educaci贸n f铆sica, Nota: 1.445982
  Id:88e29799-4120-4764-8c81-692edf8ed2ec, Alumno:Antonio Ernesto Reyes, Nombre:Matem谩ticas Eval 1, Asignatura:Matem谩ticas, Nota: 3.367313
  Id:88e29799-4120-4764-8c81-692edf8ed2ec, Alumno:Antonio Ernesto Reyes, Nombre:Educaci贸n f铆sica Eval 1, Asignatura:Educaci贸n f铆sica, Nota: 0.5068063
=================================================================
| Curso: 201, Id de curso: 4094b848-c881-4817-913a-20c8af53a0c5 |
=================================================================
  Id:28365b66-6806-4a4d-a9c8-f645b8162251, Alumno:Antonio Ernesto Flores, Nombre:Matem谩ticas Eval 1, Asignatura:Matem谩ticas, Nota: 0.9248427
  Id:28365b66-6806-4a4d-a9c8-f645b8162251, Alumno:Antonio Ernesto Flores, Nombre:Educaci贸n f铆sica Eval 1, Asignatura:Educaci贸n f铆sica, Nota: 0.2988477
  Id:1c61269a-d4c9-4f7d-b071-45807db295ac, Alumno:Antonio Ernesto Reyes, Nombre:Matem谩ticas Eval 1, Asignatura:Matem谩ticas, Nota: 0.6342252
  Id:1c61269a-d4c9-4f7d-b071-45807db295ac, Alumno:Antonio Ernesto Reyes, Nombre:Educaci贸n f铆sica Eval 1, Asignatura:Educaci贸n f铆sica, Nota: 0.2687227
=================================================================
| Curso: 301, Id de curso: f9ca4113-38d8-46de-aba8-68fae19e7654 |
=================================================================
  Id:3f7ae0ce-27d6-490d-ab7c-ad76cec0378f, Alumno:Antonio Ernesto Flores, Nombre:Matem谩ticas Eval 1, Asignatura:Matem谩ticas, Nota: 3.729126
  Id:3f7ae0ce-27d6-490d-ab7c-ad76cec0378f, Alumno:Antonio Ernesto Flores, Nombre:Educaci贸n f铆sica Eval 1, Asignatura:Educaci贸n f铆sica, Nota: 4.106187
  Id:935b227e-e5c7-4cb1-aefc-bb75d631a770, Alumno:Antonio Ernesto Reyes, Nombre:Matem谩ticas Eval 1, Asignatura:Matem谩ticas, Nota: 2.268573
  Id:935b227e-e5c7-4cb1-aefc-bb75d631a770, Alumno:Antonio Ernesto Reyes, Nombre:Educaci贸n f铆sica Eval 1, Asignatura:Educaci贸n f铆sica, Nota: 0.001697086
=================================================================
| Curso: 401, Id de curso: 7f5b4707-8c84-49e7-bea5-b23322401094 |
=================================================================
  Id:64308f90-35a4-410d-bf55-666df2cee60d, Alumno:Antonio Ernesto Flores, Nombre:Matem谩ticas Eval 1, Asignatura:Matem谩ticas, Nota: 4.863696
  Id:64308f90-35a4-410d-bf55-666df2cee60d, Alumno:Antonio Ernesto Flores, Nombre:Educaci贸n f铆sica Eval 1, Asignatura:Educaci贸n f铆sica, Nota: 1.813504
  Id:e5b2c8d2-a03e-4025-a721-c92d0e3a3b36, Alumno:Antonio Ernesto Reyes, Nombre:Matem谩ticas Eval 1, Asignatura:Matem谩ticas, Nota: 1.573842
  Id:e5b2c8d2-a03e-4025-a721-c92d0e3a3b36, Alumno:Antonio Ernesto Reyes, Nombre:Educaci贸n f铆sica Eval 1, Asignatura:Educaci贸n f铆sica, Nota: 1.214321
=================================================================
| Curso: 501, Id de curso: 5f8ede89-0ace-43cf-a471-759dfc589109 |
=================================================================
  Id:34583a17-0666-4e27-b9a4-cb65e9c23fa6, Alumno:Antonio Ernesto Flores, Nombre:Matem谩ticas Eval 1, Asignatura:Matem谩ticas, Nota: 4.191934
  Id:34583a17-0666-4e27-b9a4-cb65e9c23fa6, Alumno:Antonio Ernesto Flores, Nombre:Educaci贸n f铆sica Eval 1, Asignatura:Educaci贸n f铆sica, Nota: 1.229369
  Id:f6df3c7b-fe1f-426c-bbc5-e6f36915f6c6, Alumno:Antonio Ernesto Reyes, Nombre:Matem谩ticas Eval 1, Asignatura:Matem谩ticas, Nota: 0.05831781
  Id:f6df3c7b-fe1f-426c-bbc5-e6f36915f6c6, Alumno:Antonio Ernesto Reyes, Nombre:Educaci贸n f铆sica Eval 1, Asignatura:Educaci贸n f铆sica, Nota: 1.039719

Yo lo hice de esta forma:

La generaci贸n de nota la tome de Bruno jajaja.
Pero as铆 me quedo, acepto sugerencias y correciones.

        private void CargarEvaluaciones()
        {
            var listaEvaluaciones = new List<Evaluaciones>();

            foreach (var curso in Escuela.Cursos)
            {
                foreach (var asignatura in curso.Asignaturas)
                {
                    foreach (var alumno in curso.Alumnos)
                    {
                        for (int i= 1; i<=5; i++)
                        {
                            var evalucion = new Evaluaciones();
                            evalucion.Nombre = $"Evalucacion {i}";
                            evalucion.Asignatura = asignatura;
                            evalucion.Alumno = alumno;
                            evalucion.Nota = (float)getRandomMark();
                            listaEvaluaciones.Add(evalucion);
                        }
                    }
                }
            }
        }

        decimal getRandomMark()
        {
            Random random = new Random();
            decimal mark = random.Next(1, 50);
            mark /= 10;
            // redondeamos a un decimal
            return decimal.Round(mark, 1);
        }
foreach (var curso in Escuela.Cursos)
            {
                string[] evaluaciones = { "Examen 1", "Examen 2", "Examen 3", "Examen 4", "Examen 5" };
                Random rnd = new Random();

                var listaEvaluaciones = from evaluacion in evaluaciones
                                        from asignatura in curso.Asignaturas
                                        from alumno in curso.Alumnos
                                        select new Evaluaciones()
                                        {
                                            Nombre = evaluacion,
                                            Asignatura = asignatura,
                                            Alumno = alumno,
                                            Nota = (float)((rnd.NextDouble() * 10.0) % 5.0)
                                        };

                curso.Evaluaciones = listaEvaluaciones.ToList();
            }
<code>

Yo cargue las evaluaciones a su respectiva asignatura para tener un poco m谩s de orden.

private void CargarEvaluaciones()
        {
            Random rnd = new Random();
            foreach(var curso in Escuela.Cursos)
            {
                foreach(var asignatura in curso.Asignaturas)
                {
                    foreach(var alumno in curso.Alumnos)
                    {
                        for(var i = 0; i < asignatura.NumeroEvaluaciones; i++)
                        {

                            asignatura.ListaEvaluaciones.Add(new Evaluacion()
                            {
                                Nombre = $"evaluacion {i + 1}",
                                Alumno = alumno,
                                Asignatura = asignatura,
                                Nota = rnd.NextDouble() * (5.0 - 1.0) + 1.0
                        });
                        }
                    }
                }
            }
        }

Yo cree un nuevo objeto de evaluaciones, primero declarando un constructor desde la clase Evaluaci贸n.

private void CargarEvaluaciones()
        {
            Random rnd = new Random();
            var evaluacionesGenerales = new List<Evaluacion>();
            foreach (var curso in Escuela.Cursos)
            {
                foreach (var alumno in curso.Alumnos)
                {
                    foreach (var asignatura in curso.Asignaturas)
                    {
                        float nota = rnd.Next(0,5);
                        evaluacionesGenerales.Add(new Evaluacion(curso.Nombre,alumno,asignatura,nota));
                    }
                }
            }
            
        }

buen curso

Estara bien?

 private void CargarEvaluaciones()
        {
            foreach (var curso in Escuela.Cursos)
            {
                foreach (var asignatura in curso.Asignaturas)
                {
                    foreach (var alumn in curso.Alumnos)
                    {
                        Evaluaciones Examenes = new Evaluaciones();
                        string[] nombreEvaluacionesp = {"Examen 1:", "Examen 2:", "Examen 2:", "Examen 4:","Examen 5:"};
                        Random rnd = new Random();

                        foreach (var item in nombreEvaluacionesp)
                        {
                            Examenes.Nombre = item;
                            Examenes.Alumno = alumn;
                            Examenes.Asignatura = asignatura;
                            Examenes.Nota = (float)rnd.Next(0,5);

                        }
                    }                    
                }
            }
        }
private void CargarEvaluaciones(int qty = 5)
        {
            foreach (var curso in Escuela.Cursos)
            {
                foreach (var asignatura in curso.Asignaturas)
                {
                    for (int i = 0; i < qty; i++)
                    {
                        var evaluaciones = from alum in curso.Alumnos
                                           select new Evaluacion
                                           {
                                               Alumno = alum,
                                               Asignatura = asignatura,
                                               Nombre = $"Curso {curso.Nombre} Evaluaci贸n {i + 1} {asignatura.Nombre}",
                                               Nota = NoteSimulator()
                                           };
                        Evaluaciones.AddRange(evaluaciones);
                    }

                }

            }

        }

        private float NoteSimulator()
        {
            var rand = new Random();
            float result = (float)Math.Round(rand.NextDouble() * 5, 2);
            return result;
        }
    private void CargarEvaluaciones()
    {
        List<String> nombres =crearNombreEvaluaciones();
        Random r=new Random();
        foreach (Curso curso in Escuela.Cursos)
        {
            List<Alumno> alumnos=curso.Alumnos;
            List<Asignatura> asignaturas=curso.Asignaturas;

            var evaluaciones= from n1 in nombres
                                                from a1 in alumnos
                                                from as1 in asignaturas
                                                select new Evaluaciones{Nombre=n1,Alumno=a1,Asignatura=as1,Calificacion=float.Parse((r.NextDouble()*r.Next(0,5)).ToString()) };
            curso.Evaluaciones=evaluaciones.ToList();        
        }

    }

    private List<String> crearNombreEvaluaciones()
    {
        string[] nombre1= {"Parcial","Final"};
        string[] tipo={"Pr谩ctico","Teorico","Oral"};
        var listaNombresEvaluaciones=from n1 in nombre1
                                from t in tipo
                                select new String($"{n1} {t}");
        return listaNombresEvaluaciones.Take(5).ToList();
    }

Yo utilice este c贸digo para practicar el uso de los los m茅todos.

class Program
{
static void Main(string[] args)
{
var engine = new EscuelaEngine();
engine.Inicializar();
Printer.WriteTitle(鈥淏IENVENIDOS A LA ESCUELA鈥);
//Printer.Beep(10000, cantidad: 10);
ImpimirCursosEscuela(engine.Escuela);
var listaObjetos = engine.GetObjetosEscuela();
}

    private static void ImpimirCursosEscuela(Escuela escuela)
    {

        Printer.WriteTitle("Cursos de la Escuela");


        if (escuela?.Cursos != null)
        {
            foreach (var curso in escuela.Cursos)
            {
                WriteLine($"Nombre {curso.Nombre  }, Id  {curso.UniqueId}");
            }
        }
    }
}

}

Yo lo solucion茅 as铆:

        private void CargarEvaluaciones()
        {
            string[] nombresEval = {"1er Parcial","2do Parcial","Final","Extra","T.S."};
            foreach (Curso cur in escuela.Cursos)
            {
                Random rnd = new Random();
                var listaEvaluaciones =    from asig in cur.Asignaturas
                                            from alu in cur.Alumnos
                                            from nmEval in nombresEval
                                            select new Evaluaciones {Alumno = alu, Nota = (float)rnd.NextDouble() * 5, Asignatura = asig, Nombre = nmEval};
                cur.lstEvaluaciones = listaEvaluaciones.OrderBy((al) => al.UniqueID).Take(5).ToList();
            }
        }
        //*******************************

Yo lo solucion茅 con bucles foreach.

private void CargarEvaluaciones(int cantidad)
{
  Random rnd = new Random();
  List<Evaluacion> evaluaciones = new List<Evaluacion>();
  foreach(Curso curso in Escuela.Cursos) {
    foreach(Alumno alumno in curso.Alumnos)
      foreach(Asignatura asignatura in curso.Asignaturas)
        for (int i = 0; i < cantidad; i++)
          evaluaciones.Add(new Evaluacion($"Evaluaci贸n {i+1}", alumno, asignatura, (float) rnd.Next(0, 51)/10));
    curso.Evaluaciones = evaluaciones;
  }
}

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:

private void CargarEvaluaciones(Curso curso)
        {
            string[] nombreEvaluaciones = {"Parcial 1", "Parcial 2", "Parcial 3",
                                            "Examen Final", "Extraordinario"};
            Random rand = new Random();
            var evaluaciones = from evaluacionNombre in nombreEvaluaciones
                               from alumno in curso.Alumnos
                               from asignaturas in curso.Asignaturas
                               select new Evaluaciones
                               {
                                   Nombre = evaluacionNombre,
                                   Alumno = alumno,
                                   Asignatura = asignaturas,
                                   Nota = (float) (rand.Next(0, 5) + rand.NextDouble())
                               };
        }

Estar谩 bien as铆?

private void CargarEvaluaciones()
        {
            List<Evaluaciones> evaluacion = new List<Evaluaciones>();

            foreach (var cursos in escuela.cursos)
            {
                foreach (var alumnos in cursos.Alumnos)
                {
                    foreach (var asignaturas in cursos.Asignaturas)
                    {
                        evaluacion = GenerarEvaluacionesAlAzar(cursos, alumnos, asignaturas);
                    }
                }
            }
        }

        private List<Evaluaciones> GenerarEvaluacionesAlAzar(Curso cursos, Alumno alumnos, Asignatura asignaturas)
        {
            string[] nombre1 = { "A", "B", "C" };
            string[] nombre2 = { "1", "2", "3", "4" };
            Random rnd = new Random();
            float nota = (float)rnd.NextDouble();
            var nombresEvaluaciones = from n1 in nombre1
                                      from n2 in nombre2
                                      select new Evaluaciones { Nombre = $"{n1} - {n2}", Alumno = alumnos, Asignatura = asignaturas, Nota = nota };
            return nombresEvaluaciones.ToList();
        }

No entend铆 muy bien las instrucciones pero aqu铆 esta lo que hice xD
Escuela > Cursos > Asignaturas > Alumnos > Evaluaciones (As铆 organic茅 mi escuela pues me pareci贸 mas l贸gico)
Hice un m茅todo que genera un array con datos aleatorios de tipo double, despu茅s con foreach recorr铆 cada evaluaci贸n de cada estudiante en cada asignatura en cada curso de la escuela y le asign茅 los valores del array con su respectiva posici贸n.
Aunque funciona me parece que est谩 poco optimizado y s茅 que hay mejores maneras de escribirlo, si alguien tiene algunas recomendaciones se los agradecer铆a.

////funcion (metodo) que despues se invoca (en AssignEvaluationsData) 
        ///para generar un array con datos aleatorios de tipo double. (retorna double[]).
        public double[] GenerateStudentsEvaluationsData()
        {
            double[] evaluationsDataList1 = new double[10];
            int arrayPosition = 0;
            while (arrayPosition < 5)
            {
            double quantity;
            Random rnd = new Random();
            quantity = rnd.NextDouble();
            evaluationsDataList1[arrayPosition]= quantity;
            arrayPosition++;
            }return evaluationsDataList1;
        } 
///Asigna los valores nombre y valor de evaluacion (double) creados aleatoriamente 
        ///a cada miembro de la lista de evaluaciones(5 objetos por estudiante) 
        ///de cada estudiante, dentro de cada asignatura(subject) dentro de cada
        /// curso (course) dentro de escuela (school)
        public void AssignEvaluationsDataToStudent()
        {
            foreach (var course in schoolCopy1.schoolCourses)
            {
                foreach (var subject in course.subjects)
                {
                    foreach (var student in subject.studentsList)
                    {
                        int arrayPosition =0;
                        double[] temp =new double[4];
                        temp = GenerateStudentsEvaluationsData();
                        foreach (var evaluation in student.evaluations)
                        {
                            evaluation.evaluationName = $"partial {arrayPosition}";
                            evaluation.evaluationValue = temp[arrayPosition];
                            arrayPosition++;
                        }
                    }
                }
            }
        }




En teoria funciona jajaja鈥

        private void CargarEvaluaciones()
            {
                string[] NomEv = {"Parcial", "IEFI", "Final", "Recuperatorio", "Practico"};
                Random rnd = new Random();
                
                foreach (var c in Escuela.Cursos)
                {
                    List<Alumno> Alumn = c.Alumnos;
                    List<Asignatura> Asig = c.Asignaturas;

                    float notaRnd = (float) (rnd.NextDouble() * 5.0);
                    var carEv = from al1 in Alumn
                                from as1 in Asig
                                from ne1 in NomEv
                                select new Evaluaciones{Alumno=al1, Asignatura=as1, Nombre=ne1, Nota=notaRnd}; 
                }
            }
    private void CargarEvaluaciones(List<Curso> cursos)
    {
        // To do pending
        String[] nameEvaluaciones = {"Parcial 1", "Parcial 2", "Parcial 3", "Examen final", "Examen sorpresa"};
        Random random= new Random();
        foreach (var curso in cursos)
        {
            var evaluaciones = from nombre in nameEvaluaciones
                               from alumno in curso.Alumnos
                               from asignatura in curso.Asignaturas
                               select new Evaluaciones { Nombre = nombre, 
                                                         Alumno = alumno,
                                                         Asignatura = asignatura,
                                                         Nota = generarNotalAleatorio(random)
                                                       };
            curso.evaluaciaones = evaluaciones.ToList();
        } 

    }

    private float generarNotalAleatorio(Random rd){
        var notaEntera =  rd.Next(0, 5);
        if(notaEntera < 5){
            return float.Parse((notaEntera + rd.NextDouble()).ToString().Substring(0, 3));
        }    
        return (float)notaEntera;
    }

Aca esta mi solucion

 private void GenerateExams()
        {
             Random rnd = new Random();
             int[] cantityExamsArray = { 1, 2, 3, 4, 5 };

            foreach (var course in School.Courses)
            {
               var exams = from student in course.Students
                          from subject in  course.Subjects
                          from examNumber in cantityExamsArray
                          select new Exam() {
                                Name = $"{course.Name} ({subject.Name}) - Exam  #{examNumber}", 
                                Student = student,
                                Subject = subject,
                                Score = float.Parse((rnd.NextDouble()/2).ToString().Substring(0, 3))
                              };
                course.Exams = exams.ToList();

            }
        }

Yo lo solucione de esta forma si alguien me pudiera dar su opini贸n se los agradecer铆a mucho


static void Main(string[] args)
        {         
          
           string[] listaCursos = {"Matematica","Catellano","Educaci贸n F铆sica","Ciencias Naturales"};
           string[] nombreAlumnos = { "Alba", "Felipa", "Eusebio", "Farid", "Donald", "Alvaro", "Nicol谩s" };    
           
            
            IEnumerable<string> listaAlumnos =  
                                from n1 in listaCursos                               
                                from a1 in nombreAlumnos
                                from n2 in notasAleatoriasDecimal() 
                                select $"Curso: {n1}, Alumno {a1}, Criterio Evaluacion : {n2.ToString("N1")}"  ;


            foreach (var item in listaAlumnos)
            {
                System.Console.WriteLine(item); 
            }

        }
        
        public static List<Double> notasAleatoriasDecimal()
        {         
            List<Double> notas = new List<Double>();
            Random notaAleatoria = new Random();

            double val1 = 0.0;
            double val2 = 5.0;     

            double[] asignar = new double[5]; 

            for (int i = 0; i < 5; i++) {

            var next = notaAleatoria.NextDouble();    
            
            asignar[i] = val2 + (next * (val1 - val2));         
          
            notas.Add(asignar[i]);
            }   
            
            return notas;

        }
<code>
public void LoadEvaluations(Courses course){
            Random rnd = new Random();
            foreach (var student in course.Students){
                student.Subjects = (course.Subjects);
                foreach (var subject in student.Subjects){
                    List<Evaluation> evaluationList = new List<Evaluation>(){
                        new Evaluation(){ Name="Quiz", Score= (((float) rnd.NextDouble())*5/1), Subject=subject.Name},
                        new Evaluation(){ Name="Parcial", Score= (((float) rnd.NextDouble())*5/1), Subject=subject.Name },
                        new Evaluation(){ Name="Expo", Score= (((float) rnd.NextDouble())*5/1), Subject=subject.Name },
                        new Evaluation(){ Name="HomeWork", Score= (((float) rnd.NextDouble())*5/1), Subject=subject.Name },
                        new Evaluation(){ Name="Proyect", Score= (((float) rnd.NextDouble())*5/1), Subject=subject.Name }
                    };
                    subject.Evaluations = (evaluationList);
                }
            }
            
        }

No me gusta como da el curso, va para atras y para adelante.
Te mareas con las 10 formas de hacer lo mismo.
Cambia lo que ya estaba armado.
Se nota que muchas de las cosas las hizo al momento y tiene errores que te hacen confundir.
Habla muy r谩pido.
Algunos conceptos los explica a fondo de forma innecesaria y otros da por hecho que ya el estudiante lo sepa.

Cuesta mucho seguir el hilo del curso

public void CargarEvaluacionesAleatorias()
        {
            foreach (Curso curso in Escuela.Cursos)
            {
                List<Evaluacion> HolderEvaluaciones = new List<Evaluacion>();
                foreach (Alumno alumno in curso.Alumnos)
                {
                    foreach (Asignatura asignatura in curso.Asignaturas)
                    {
                        HolderEvaluaciones.Add(new Evaluacion("Evaluaci贸n 1", alumno, asignatura, random.NextDouble()*5));
                        HolderEvaluaciones.Add(new Evaluacion("Evaluaci贸n 2", alumno, asignatura, random.NextDouble()*5));
                        HolderEvaluaciones.Add(new Evaluacion("Evaluaci贸n 3", alumno, asignatura, random.NextDouble()*5));
                        HolderEvaluaciones.Add(new Evaluacion("Evaluaci贸n 4", alumno, asignatura, random.NextDouble()*5));
                        HolderEvaluaciones.Add(new Evaluacion("Evaluaci贸n 5", alumno, asignatura, random.NextDouble()*5));
                    }
                }
                curso.Evaluaciones = HolderEvaluaciones;
                HolderEvaluaciones = null;
            }
        }```
private void cargarEvaluaciones()
        {
            string[] listaEvaluaciones = { "Examen1", "Examen2", "Examen3", "Tarea1", "Tarea2" };
            Random rnd = new Random();
            foreach (var cursos in escuela.cursos)
            {
                foreach (var asig in cursos.asignatura)
                {
                    foreach (var alumno in cursos.alumno)
                    {
                        //long i = listaEvaluaciones.Length;
                        foreach (var x in listaEvaluaciones)
                        {
                            var ev = new evaluaciones()
                            {
                                asignatura = asig,
                                Nombre = x,
                                nota = (float)(5 * rnd.NextDouble()),
                                alumno = alumno
                            };
                        }
                    }
                }
            }
        }```

dentro de escuela.Util class: DebugGenerations

        public static List<Evaluacion> GenerarEvaluaciones(List<Alumno> alumnos){
            var evals = new List<Evaluacion>(); 
            // tarea 10,actividad 1 20, Actividad 2 20, Lab 20, Examen 30

                foreach (var alumno in alumnos)
                {
                   var tmp = new List<Evaluacion>(){
                       new Evaluacion{Name = "Tareas",Ponderacion = 10,Alumno = alumno, Nota = randonFloat()},
                       new Evaluacion{Name = "Actividad 1",Ponderacion = 20,Alumno = alumno, Nota = randonFloat()},
                       new Evaluacion{Name = "Actividad 2",Ponderacion = 20,Alumno = alumno, Nota = randonFloat()},
                       new Evaluacion{Name = "Lab",Ponderacion = 20,Alumno = alumno, Nota = randonFloat()},
                       new Evaluacion{Name = "Examen",Ponderacion = 30,Alumno = alumno, Nota = randonFloat()}
                   };
                    evals.AddRange(tmp);
                }

            return evals;
        }

y dentro del engine:

        private void LoadTests()
        {
            /// DEBUG GENERACION ALEATORIA
            foreach (var curso in Escuela.Cursos)
            {
                foreach (var asignatura in curso.Asignaturas)
                {
                    asignatura.Evaluaciones = DebugGenerations.GenerarEvaluaciones(curso.Alumnos);
                }
            }

Yo hice lo siguiente, hice una serie de modificaciones al c贸digo:
Initialize me quedo as铆:

 public void Initialize()
        {
            School = new School("Platzi", 1997, TypeSchool.Basic, city: "Bogota", country: "Venezuela");
            LoadCourses();
        }

A la funci贸n de cargar clases, la cambi茅 para que retornara la lista en vez de que fuera void

   private List<Class> LoadClasses()
        {
              List<Class> ClassesList = new List<Class>(){
                    new Class{Name = "Math"},
                    new Class{Name = "Language"},
                    new Class{Name = "Biology"},
                    new Class{Name = "Science"},
                    new Class{Name = "Chemestry"}
                };
            // course.Classes = ClassesList;

            return ClassesList;
        }

Luego hice mi funci贸n para generar las evaluaciones/asignaciones.

        private List<Assignment> GenerateAssignments(List<Class> classes){
            
            var assigmentList = new List<Assignment>();            
            int assignmentXClass = 5;
            int count = 0;
            for (int i = 0; i < 20; i++)
            {
                if(assignmentXClass == 5){
                    assignmentXClass = 0;
                    count++;
                }    
                assigmentList.Add(new Assignment{Name = "Assignment" + i, Class = classes[count]});
                assignmentXClass++;
            }

            return assigmentList;
        }

Luego gener茅 una funci贸n para asignar a unos estudiantes de un curso sus asignaciones:

 private void SetAssignmentForStudents(List<Assignment> assignments,List<Student> students){
            Random rnd = new Random();
            foreach (var student in students)
            {
                var assignment = assignments[rnd.Next(0,assignments.Count)];
                var calification = RandomFloat(0,5);
                assignment.Student = student;
                assignment.Calification = (float)calification;
            }
        }

Por 煤ltimo aprovech茅 el for de la funci贸n de cargar cursos para llamar a las anteriores funciones:

 private void LoadCourses()
        {
            var coursesList = new List<Course>(){
                new Course(){Name = "101", Journey = TypeJourneys.Morning},
                new Course(){Name = "102", Journey = TypeJourneys.Afternoon},
                new Course(){Name = "103", Journey = TypeJourneys.Night}
            };

            School.Courses = coursesList;
            Random rnd = new Random();
            var classes = LoadClasses();
            var assignments = GenerateAssignments(classes);
            foreach (var course in School.Courses)
            {
                int quantity = rnd.Next(5,20);
                course.Classes = classes;
                course.Students = GenerateStudents(quantity);
                course.Assignments = assignments;
                SetAssignmentForStudents(course.Assignments,course.Students);
            }
        }

Realmente creo que esto rompe el principio de manterlo simple, pero funciona, despues refactorizo.

        public void CargarEvaluciones()
        {
            foreach (var curso in Escuela.Cursos)
            {
                foreach (var alumno in curso.Alumnos)
                {
                    alumno.Asignaturas = curso.Asignaturas;

                    foreach (var asignatura in alumno.Asignaturas)
                    {
                        List<Evaluaciones> evaluaciones = new List<Evaluaciones>()
                        {
                        new Evaluaciones{Nombre = "Primer Parcial"},
                        new Evaluaciones{Nombre = "Segundo Parcial"},
                        new Evaluaciones{Nombre = "Tercero Parcial"},
                        new Evaluaciones{Nombre = "Cuarto Parcial"},
                        new Evaluaciones{Nombre = "Quinto Parcial"}
                        };

                        asignatura.Evaluaciones = evaluaciones;

                        foreach (var evaluacion in asignatura.Evaluaciones)
                        {
                            evaluacion.Alumno = alumno.Nombre;
                            evaluacion.Asignatura = asignatura.Nombre;

                            Random rnd = new Random();
                            double cantRandom = Math.Round(rnd.NextDouble() * 0.5, 2);

                            evaluacion.Nota = cantRandom;

                        }
                    } 
                }
            }
        }
private void AddExamRandomly()
        {
            Random random = new Random();
            foreach (var course in School.Courses)
            {
                foreach (var student in course.Students)
                {
                    List<Exam> examsList = new List<Exam>()
                    {
                        new Exam("Mathematics Exam", $"{student.Name}", random.NextDouble() * (5.0 - 0.1) + 0.1),
                        new Exam("English Exam", $"{student.Name}", random.NextDouble() * (5.0 - 0.1) + 0.1),
                        new Exam("Cience Exam", $"{student.Name}", random.NextDouble() * (5.0 - 0.1) + 0.1),
                        new Exam("Philosophy Exam", $"{student.Name}", random.NextDouble() * (5.0 - 0.1) + 0.1),
                    };
                    student.Exams = examsList;
                }
            }
        }


Metodo GeneracionEvaluacionesAlAzar

Metodo GetRandomNumber

Metodo Asignar Evaluaciones

Llamado a la generaci贸n y asignaci贸n de las evaluaciones

No qued贸 breve. ya veremos en el siguiente cap

    private void CargarEvaluaciones()
    {
      int counter = 0;
      int counter_alumn = 0;

      List<Evaluaciones> evaluaciones = new List<Evaluaciones>();
      foreach (var curso in Escuela.Cursos)
      {
        foreach (var alumno in curso.Alumnos)
        {
          counter_alumn++;
          foreach (var Asignatura in curso.Asignaturas)
          {
            for (int i = 0; i < 5; i++)
            {
              Random rand = new Random();
              double numb = rand.NextDouble();
              double averagesDoubles = Math.Round(numb, 1);
              float nota = Convert.ToSingle(Math.Round((averagesDoubles * 5.0 / 0.9), 1));
              counter++;
              var evas = new Evaluaciones();
              evas.Nombre = "Evaluacion No. " + counter.ToString();
              evas.Asignatura = Asignatura;
              evas.Alumno = alumno;
              evas.Nota = nota;
              evaluaciones.Add(evas);
              WriteLine($"{evas.Nombre}\n Asignatura: {evas.Asignatura.Nombre}| Alumno: {evas.Alumno.Nombre}| Nota: {nota}");

            }

          }
        }
      }
      WriteLine($"Total evaluaciones: {evaluaciones.Count()} | Total alumnos: {counter_alumn}  ");
    }```

S.O.S

No pude aprovechar el curso, y me frustra por que la soluci贸n final del reto no se explic贸 ni se mostr贸 como deberia @JuanCarlosRuiz. Me gust贸 la forma en la que explic贸 durante el curso.

@TeamPlatzi alguno me puede ayudar a terminar mi soluci贸n o ver si se puede subir aqu铆 la soluci贸n de JuanCarlosRuiz??

Saludos

Este es mi metodo, reto cumplido鉁岎煆

private void CargarEvaluaciones()
        {
            int cantAsignatura = 0;            
            foreach(var curso in Escuela.Cursos)
            {
                var Evaluaciones = new List<Evaluacion>();
                for (int i = 0; i < curso.Alumnos.Count; i++)
                {                    
                    Evaluaciones.Add(new Evaluacion
                    {
                        Nombre = (TiposEvaluacion)(new Random().Next(0, 3)),
                        Alumno = curso.Alumnos.ElementAt(i),
                        Asignatura = curso.Asignaturas.ElementAt(cantAsignatura),                     
                        Nota = (float)Math.Round(new Random().NextDouble()+(new Random().Next(0, 4)), 1)
                    });                    
                    if(cantAsignatura >= curso.Asignaturas.Count-1)
                        cantAsignatura = -1;
                    cantAsignatura++;
                }
                curso.Evaluaciones = Evaluaciones;
            }
        }

Para los tipos de evaluaciones cree otro enumerado especificando cada tipo, como lo hicimos con los tipos de jornadas y los tipos de escuelas.
Tambien agregue otro atributo a la clase Curso el cual fue una lista de evaluaciones para poder almacenar todas las evaluaciones en algun lado.
Si no entienden algo no duden en preguntar.

 private static void ImprimirNotas(List<Evaluacion> evaluacions)
        {
            evaluacions.OrderBy(ev => ev.Asignatura.Nombre);
            string alumnoActual = string.Empty;
            Console.WriteLine("=================================================================================");

            foreach (var evaluacion in evaluacions)
            {
                if (alumnoActual != evaluacion.Alumno.Nombre)
                {
                    Console.WriteLine($"===============  {evaluacion.Alumno.Nombre.ToUpper()}  =================");
                }
                                
                Console.WriteLine($"Nombre: {evaluacion.Nombre}, Alumno: {evaluacion.Alumno.Nombre}, Asignatura: {evaluacion.Asignatura.Nombre}, Nota: {evaluacion.Nota}");

                alumnoActual = evaluacion.Alumno.Nombre;
            }

            Console.WriteLine("=================================================================================");
        }```

Tengo que admitir que me llev贸 un par de horas comprenderlo y armar una soluci贸n lo menos rebuscada posible, tal cual vimos las estructuras de las clases no se pueden evitar las iteraciones, pero dentro de todo siento que la soluci贸n qued贸 algo limpia :

Pd. Mi forma de comprobarlo fue sumar los alumnos generados aleatoria-mente dentro de los cursos, por ejemplo en una ejecuci贸n me sali贸 as铆:
Curso 101 : 19 alumnos, Curso 201 : 6 alumnos, Curso 301 : 18 alumnos, Curso 401 : 6 alumnos Curso 14 alumnos.

63 alumnos por 5 asignaturas por 5 evaluaciones = 1575 cursos. ese mismo n煤mero me da el count de mi m茅todo CargarEvaluaciones

  private List<Evaluaciones> CargarEvaluaciones()
        {
           var evaluaciones = new List<Evaluaciones>();
            // Por cada Curso
            Escuela.Cursos.ForEach(curso => 
            {
                // De cada Alumno
                curso.Alumnos.ForEach(alumno  => 
               {
                   curso.Asignaturas.ForEach(asignatura =>
                   {
                       // 5 Evaluaciones por Asignatura
                          for (int i = 0; i <= 4; i++)
                          {
                                 evaluaciones.Add(new Evaluaciones()
                                     {
                                       Asignatura = asignatura,
                                       Calificacion =  new Random().Next(0,5) + (float)new Random().NextDouble(),
                                       Nombre = $"Parcial : {i + 1}",
                                       Alumno = alumno
                                     });
                         }
                  });
               });
            });
            return evaluaciones;
        }```

Lo solucione de la siguiente forma:

    private void CargarEvaluaciones()
    {
        foreach (var curso in Escuela.Cursos)
        {
            foreach (var asignatura in curso.Asignaturas) 
            {
                foreach (var alumno in curso.Alumnos)
                {
                    List<Evaluacion> evaluaciones = new List<Evaluacion>();
                    for (int i = 1; i <= 5; i++){
                        Random random = new Random();
                        evaluaciones.Add(new Evaluacion() { Nombre       = "Parcial " + i, 
                                                            Asignatura   = asignatura, 
                                                            Calificacion = (float) (5 * random.NextDouble())});
                    }
                    alumno.Evaluaciones = evaluaciones;
                 }
            }
        }
    }

Clase Alumno

EscuelaEngine.cs

        private void CargarEvaluaciones()
        {
            foreach (var c in Escuela.Cursos)
            {
                foreach (var a in c.Asignaturas)
                {
                    foreach (var al in c.Alumnos)
                    {
                        Random rndNotaPRE = new Random();
                        int notaRandom = rndNotaPRE.Next(0,50);
                        float notaRandomFloat = ((float)notaRandom)/10;
                        var ev1 = new Evaluaciones{Alumno=al,Asignatura=a,Nombre="Quiz #1"+a.Nombre,Nota=notaRandomFloat};
                        var ev2 = new Evaluaciones{Alumno=al,Asignatura=a,Nombre="Primer Examen"+a.Nombre,Nota=notaRandomFloat};
                        var ev3 = new Evaluaciones{Alumno=al,Asignatura=a,Nombre="Examen Primer Corte"+a.Nombre,Nota=notaRandomFloat};
                        var ev4 = new Evaluaciones{Alumno=al,Asignatura=a,Nombre="Quiz #2"+a.Nombre,Nota=notaRandomFloat};
                        var ev5 = new Evaluaciones{Alumno=al,Asignatura=a,Nombre="Examen Final"+a.Nombre,Nota=notaRandomFloat};

                        al.Evaluaciones = new List<Evaluaciones>();
                        
                        al.Evaluaciones.Add(ev1);
                        al.Evaluaciones.Add(ev2);
                        al.Evaluaciones.Add(ev3);
                        al.Evaluaciones.Add(ev4);
                        al.Evaluaciones.Add(ev5);

                        Printer.DibujarLinea(20);
                        Console.WriteLine("Alumno: "+ev1.Alumno.Nombre+"\n"+"Asignatura: "+ev1.Asignatura.Nombre+"\n"+"Evaluaci贸n: "+ev1.Nombre+"\n"+"Nota: "+ev1.Nota);
                        Console.WriteLine("Alumno: "+ev2.Alumno.Nombre+"\n"+"Asignatura: "+ev2.Asignatura.Nombre+"\n"+"Evaluaci贸n: "+ev2.Nombre+"\n"+"Nota: "+ev2.Nota);
                        Console.WriteLine("Alumno: "+ev3.Alumno.Nombre+"\n"+"Asignatura: "+ev3.Asignatura.Nombre+"\n"+"Evaluaci贸n: "+ev3.Nombre+"\n"+"Nota: "+ev3.Nota);
                        Console.WriteLine("Alumno: "+ev4.Alumno.Nombre+"\n"+"Asignatura: "+ev4.Asignatura.Nombre+"\n"+"Evaluaci贸n: "+ev4.Nombre+"\n"+"Nota: "+ev4.Nota);
                        Console.WriteLine("Alumno: "+ev5.Alumno.Nombre+"\n"+"Asignatura: "+ev5.Asignatura.Nombre+"\n"+"Evaluaci贸n: "+ev5.Nombre+"\n"+"Nota: "+ev5.Nota);
                        Printer.DibujarLinea(20);
                    }
                }
            }
        }

Creo que as铆

  private void CargarEvaluaciones()
        {

            var evaluaciones = from curso in Escuela.Cursos
                               from ua in curso.Asignaturas
                               from al in curso.Alumnos
                               select new Evaluaciones { Nombre = "evaluacion", Alumno = al, Asignatura = ua, Nota = GenerarNota() };

        }

        private float GenerarNota()
        {
            Random ran = new Random();
            float nota = Convert.ToSingle(ran.NextDouble() / 2);
            return nota;
        }```

Se entiende Mejor

        public List<Evaluaciones> Evaluaciones{ get; set; }
        private void CargarEvaluaciones()
        {
            foreach (var c in Escuela.Cursos)
            {
                foreach (var a in c.Asignaturas)
                {
                    foreach (var al in c.Alumnos)
                    {
                        Random rndNotaPRE = new Random();
                        int notaRandom = rndNotaPRE.Next(0,50);
                        float notaRandomFloat = ((float)notaRandom)/10;
                        var ev1 = new Evaluaciones{Alumno=al,Asignatura=a,Nombre="Quiz 
                        #1"+a.Nombre,Nota=notaRandomFloat};

                        var ev2 = new Evaluaciones{Alumno=al,Asignatura=a,Nombre="Primer 
                        Examen"+a.Nombre,Nota=notaRandomFloat};

                        var ev3 = new Evaluaciones{Alumno=al,Asignatura=a,Nombre="Examen Primer 
                        Corte"+a.Nombre,Nota=notaRandomFloat};

                        var ev4 = new Evaluaciones{Alumno=al,Asignatura=a,Nombre="Quiz 
                        #2"+a.Nombre,Nota=notaRandomFloat};

                        var ev5 = new Evaluaciones{Alumno=al,Asignatura=a,Nombre="Examen 
                        Final"+a.Nombre,Nota=notaRandomFloat};

                        al.Evaluaciones = new List<Evaluaciones>();
                        
                        al.Evaluaciones.Add(ev1);
                        al.Evaluaciones.Add(ev2);
                        al.Evaluaciones.Add(ev3);
                        al.Evaluaciones.Add(ev4);
                        al.Evaluaciones.Add(ev5);

                        Printer.DibujarLinea(20);
                        Console.WriteLine("Alumno: "+ev1.Alumno.Nombre+"\n"+"Asignatura: 									 
                        "+ev1.Asignatura.Nombre+"\n"+"Evaluaci贸n: "+ev1.Nombre+"\n"+"Nota: 
                        "+ev1.Nota);

                        Console.WriteLine("Alumno: "+ev2.Alumno.Nombre+"\n"+"Asignatura: 
                        "+ev2.Asignatura.Nombre+"\n"+"Evaluaci贸n: "+ev2.Nombre+"\n"+"Nota: 
                        "+ev2.Nota);

                        Console.WriteLine("Alumno: "+ev3.Alumno.Nombre+"\n"+"Asignatura: 
                        "+ev3.Asignatura.Nombre+"\n"+"Evaluaci贸n: "+ev3.Nombre+"\n"+"Nota: 
                        "+ev3.Nota);

                        Console.WriteLine("Alumno: "+ev4.Alumno.Nombre+"\n"+"Asignatura: 
                        "+ev4.Asignatura.Nombre+"\n"+"Evaluaci贸n: "+ev4.Nombre+"\n"+"Nota: 
                        "+ev4.Nota);

                        Console.WriteLine("Alumno: "+ev5.Alumno.Nombre+"\n"+"Asignatura: 
                        "+ev5.Asignatura.Nombre+"\n"+"Evaluaci贸n: "+ev5.Nombre+"\n"+"Nota: 
                        "+ev5.Nota);

                        Printer.DibujarLinea(20);
                    }
                }
            }
        }

Tuve varios problemas implementando el c贸digo, trate de hacerlo como lista pero al retomar el valor me salia un error de que no pod铆a transformar un tipo de dato 鈥淪ystem.Collections.Generic.List鈥 a 鈥淟ist鈥 no entend铆a muy bien porque, el caso es que estuve mirando y despu茅s y no pude encontrar una forma correcta, actualmente mi codigo solo devuelve el ultimo examen creado, sin embargo lo dejo para en un futuro responderlo con una mejor implementation

using System;
using System.Collections.Generic;
using System.Linq;
using CoreEscuela.Entidades;

namespace CoreEscuela
{
    public class EscuelaEngine
    {
    public Escuela Escuela { get; set; }
    public Evaluaciones Evaluaciones { get; set; }
    // Constructor, es aconsejable alejarlo de entrada y salida de la base de datos
    public EscuelaEngine(){
        this.Inicializar();
    }
      // Metodo de tipo "void" que es un metodo que no me devuelve nada void es vacio
    public void Inicializar()
    {
      Escuela = new Escuela("Platzi Academy", 2012, TiposEscuela.Primaria,
        ciudad: "Bogota", pais: "Colombia"
      );
      CargarCursos();
      CargarAsignaturas();
      // foreach (var curso in Escuela.Cursos)
      // {
      //   curso.Alumno.AddRange(GenerandoAlumnosAlazar());
      // }
        
      // Evaluaciones = CargarEvaluaciones();
      CargarEvaluaciones();
    }

    // private List<Evaluaciones> CargarEvaluaciones()
    private void CargarEvaluaciones()
    {
      // List<Evaluaciones> evaluaciones = new List<Evaluaciones>();
      foreach (var curso in Escuela.Cursos)
      {
        // var ListEvaluaciones = from Asig in item.Asignatura
        //                    from Est in item.Alumno
        //                   //  from 
        //                   select new Evaluaciones(){
        //                     Nombre = $"Asignatuta: {Asig.Nombre}. Nombre: {Est.Nombre}",
        //                     Nota = GenerarNota(),
        //                     Alumno = Est,
        //                     Asignatura = Asig
        //                   };
        
        foreach (var alumno in curso.Alumno )
        {
          foreach (var asignatura in curso.Asignatura)
          {
           Evaluaciones = new Evaluaciones(
              $"{asignatura.Nombre} {alumno.Nombre}",
              alumno,
              asignatura,
              GenerarNota()
            );            
          }
        }
      }
    }

    private float GenerarNota(){
      Random rdm = new Random();
      float nota = (float)(rdm.NextDouble() * 10);
      return nota;
    }

    private void CargarAsignaturas()
    {
      foreach (var curso in Escuela.Cursos)
      {
        List<Asignatura> ListaAsignatura = new List<Asignatura>(){
          new Asignatura{Nombre="Matematicas"},
          new Asignatura{Nombre="Educacion Fisica"},
          new Asignatura{Nombre="Ingles"},
          new Asignatura{Nombre="Ciencias Naturales"}
        };
        // curso.Asignatura.AddRange(ListaAsignatura);
        // Se precenta inconveniente porque en asignaturas no hay nada entonces para asignar e iniciarlas de una ves pues la siguiente es una opcion
        curso.Asignatura = ListaAsignatura;
      }
    }

    private List<Alumno> GenerandoAlumnosAlazar(int Cantidad)
    {
      string[] nombre1 = {"Javier","Edward","Elon","Estela","Margarita","Corey","Luisa"};
      string[] apellido1 = {"Duarte","Cordoba","Reeve","Lopez","Tribi帽o","Todd","Solarte"};
      string[] apellido2 = {"Ruiz","Hernandez","Musk","Santos","Zarate","Dias","Taylor"};

      var listaAlumnos = from n1 in nombre1
                        from a1 in apellido1
                        from a2 in apellido2
                        select new Alumno{ Nombre=$"{n1} {a1} {a2}"};
            
      // Ordeneme de tal forma que resiva los alumnos y los ordene por id luego tomeme una cantidad especificada y modifiquelo como una lista
      return listaAlumnos.OrderBy( (Al)=> Al.UniqueId ).Take(Cantidad).ToList();
    }

    private void  CargarCursos()
      {
        Escuela.Cursos = new List<Curso>(){
          new Curso(){ Nombre = "101", Jornada = TiposJornada.Ma帽ana},
          new Curso(){ Nombre = "201", Jornada = TiposJornada.Ma帽ana},
          new Curso(){ Nombre = "301", Jornada = TiposJornada.Ma帽ana},
          new Curso(){ Nombre = "401", Jornada = TiposJornada.Tarde},
          new Curso(){ Nombre = "501", Jornada = TiposJornada.Tarde}
        };

        Random rnd = new Random();
        foreach (var i in Escuela.Cursos)
        {
          int CantRandom =  rnd.Next(2,5);
          i.Alumno = GenerandoAlumnosAlazar(CantRandom);     
        }
      }
    }
}

Elc贸digo qued贸 as铆:

Adicionalmente se agrega en la clase curso:public List<Evaluacion> Evaluaciones { get; set; }

Asi queda el reto de acuerdo a lo planteado

Se asignan evaluaciones aleatorias y se asignan a cada asignatura del curso, del mismo modo se asigna una nota aleatoria(0.0 a 5.0) para cada una de las asignaturas del curso a los que esta inscrito cada estudiante

se carga las asignaturas aleatoriamente

y luego se asignan a cada uno de los cursos

y luego se cargan las evaluaciones para cada asignatura con el criterio de 5 por asignatura

se realiza la asignacion de las evaluaciones a las asignaturas de cada curso dentro de el metodo cargar cursos

y luego se asignan las notas para cada alumno que presento las evaluaciones en cada una de las asignaturas de cada curso

asi se visualiza

Lo hice de esta manera, al curso le agregue una lista de evaluaciones de sus alumnos y asignaturas

private void CargarEvaluaciones()
        {
            int[] numEvaluacion = new int[] { 1,2,3,4,5 };
            foreach (var curso in Escuela.Cursos)
            {
                var evaluaciones = from num in numEvaluacion
                                 from alumno in curso.Alumnos
                                 from asignatura in curso.Asignaturas
                                 select new Evaluaciones {Nombre = $"Parcial {num}", Alumno = alumno, Asignatura = asignatura, Nota = GenerarNotaAlAzar(), };
                curso.Evaluaciones = evaluaciones.ToList();
            }
        }
        private float GenerarNotaAlAzar()
        {
            Random rnd = new Random();
            double cantRandom = rnd.NextDouble() * 5;
            return (float) Math.Round(cantRandom, 1);
        }```

Hola, mi soluci贸n fue la siguiente:
Primero se debe inicializar el constructor del Alumno para poder utilizar el m茅todo Add().

En el m茅todo Cargar Evaluaciones:

Adem谩s yo hice un m茅todo para generar el nombre de la evaluaci贸n y la nota:

Espero que les sea 煤til, saludos.

<code>
private void CargarEvaluaciones()
        {
            
            foreach (var curso in Escuela.Cursos)
            {
             foreach (var alumno in curso.alumnos)
             {
              foreach (var materias in curso.materias)
              {
                  for (int i = 0; i < 5; i++)
                  {
                      evaluacion evaluacion = new evaluacion()
                      {
                          Nombre = i.ToString(), nota = notaAleatoria() , Alumno = alumno , materias = materias
                      };
                  }
              }
             }

            }
        }

Mi solucion : Le amento un atributo de tipo Lista<Evaluacion> a la Escuela e inicialice las evaluaciones por cada alumno e asignatura y luego el metodo de impresion

Random rnd = new Random();
this.Escuela.Cursos.ForEach(
a => a.Alumnos = CargarAlumnos(
rnd.Next(5, 20)
)
);
foreach (Curso cur in this.Escuela.Cursos)
{
foreach (Alumno al in cur.Alumnos)
{
al.Asignaturas = CargarAsignatura();
al.Asignaturas.ForEach(
e => e.Evaluacion = CargarEvaluacion()
);
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using CoreEscuela.Entidades;

namespace CoreEscuela{
    public class EscuelaEngine{

        public Escuela Escuela{get;set;}

        public void Inicializar(){
            Escuela = new Escuela("Platzi", 2020, TiposEscuela.Preescolar, "Colombia", "Bogota");
            CargarCursos();
            CargarAsignaturas();
        }

        private void CargarAsignaturas()
        {
            foreach (var curso in Escuela.cursos)
            {
                List<Asignatura> listaAsignaturas = new List<Asignatura>(){
                    new Asignatura{Nombre = "Matem谩ticas"},
                    new Asignatura{Nombre = "Educaci贸n F铆sica"},
                    new Asignatura{Nombre = "Castellano"},
                    new Asignatura{Nombre = "Ciencias Naturales"}
                };
                curso.Asignaturas = listaAsignaturas;
            }
        }

        private List<Alumno> GenerarAlumnosAlAzar( int cantidad)
        {
            string[] nombre1 = { "Alba", "Felipa", "Eusebio", "Farid", "Donald", "Alvaro", "Nicol谩s" };
            string[] apellido1 = { "Ruiz", "Sarmiento", "Uribe", "Maduro", "Trump", "Toledo", "Herrera" };
            string[] nombre2 = { "Freddy", "Anabel", "Rick", "Murty", "Silvana", "Diomedes", "Nicomedes", "Teodoro" };

            //De esta manera se realiza una query a los arreglos atenriores y se colocan en el alumno de manera aleatorio
            var listaAlumnos = from n1 in nombre1 
            from n2 in nombre2 
            from a1 in apellido1 select new Alumno{ Nombre=$"{n1} {n2} {a1}"};
            return listaAlumnos.OrderBy((al)=>al.UniqueId).Take(cantidad).ToList();
        }

        public void CargarCursos(){
            Escuela.cursos = new List<Curso>(){
                new Curso(){ Nombre = "101",Jornada = TiposJornada.Ma帽ana },
                new Curso(){ Nombre = "201",Jornada = TiposJornada.Ma帽ana },
                new Curso(){ Nombre = "301",Jornada = TiposJornada.Ma帽ana},
                new Curso(){ Nombre = "401",Jornada = TiposJornada.Tarde },
                new Curso(){ Nombre = "501",Jornada = TiposJornada.Tarde }
            };
            Random rnd = new Random();
            foreach (var curso in Escuela.cursos)
            {
                int cantRandom = rnd.Next(5,20);
                curso.Alumnos = GenerarAlumnosAlAzar(cantRandom);
                foreach (var alumno in curso.Alumnos)
                {
                    alumno.Asignaturas = CargarEvaluaciones();
                }
            }
        }

        private List<Asignatura> CargarEvaluaciones()
        {
            List<Asignatura> listaAsignaturas = new List<Asignatura>(){
                    new Asignatura{Nombre = "Matem谩ticas"},
                    new Asignatura{Nombre = "Educaci贸n F铆sica"},
                    new Asignatura{Nombre = "Castellano"},
                    new Asignatura{Nombre = "Ciencias Naturales"}
            };
            Random rnd = new Random();
            foreach (var asignaturas in listaAsignaturas)
            {
                double cantRandom = rnd.NextDouble()*(5);
                //double notaProm = cantRandom*(5);
                //decimal nota = Decimal.Round( (Decimal)cantRandom,1);
                asignaturas.Nota = Decimal.Round((Decimal)cantRandom,1);
            }
            return listaAsignaturas;
        }
    }
}

private List<Evaluacion> GenerarEvaluacionesAlAzar(Alumno alumno, Asignatura asignatura,int cantidad = 5)
{
Random rnd = new Random();
var listaEvaluaciones= new List<Evaluacion>();

        Printer.WriteTitle("Evaluaciones");
        
        for (int i = 0; i < cantidad; i++)
        {
            var evaluacion = new Evaluacion()
                {
                    Nombre=$"Evaluacion {i+1}",
                    Jornada =  ((TiposJornada)rnd.Next(0,2)) ,
                    Alumno = alumno,
                    Asignatura = asignatura,
                    Nota = float.Parse($"{rnd.Next(0,10)}.{rnd.Next(0,9)}")
                };
            listaEvaluaciones.Add(evaluacion);
            Console.WriteLine($"Nombre:{evaluacion.Nombre} Jornada:{evaluacion.Jornada.ToString()} Alumno:{evaluacion.Alumno.Nombre} Asignatura:{evaluacion.Asignatura.Nombre} Nota:{evaluacion.Nota.ToString()}");
        }
        return listaEvaluaciones;
    }


    private void CargarEvaluaciones()
    {
        //1. Recorremos os cursos de la escuela
        foreach (var curso in Escuela.Cursos)
        {
            //2. Recorremos las asignaturas  de los cursos de la escuela
            foreach (var asignatura in curso.Asignaturas)
            {
                // 3. Suponiendo qu eel curso consta de N materias y todos los alumnos ingresan 
                foreach (var alumno in curso.Alumnos)
                {
                    GenerarEvaluacionesAlAzar(alumno: alumno, asignatura:asignatura);
                }
            }
        }
    }

Mi solucion no cumplia con todos los requisitos, pero my bien el reto para practicar todo lo aprendido.

Soluci贸n del reto:

primero a la clase Alumno le agregue una lista de asignaturas,

despu茅s a la clase Asignatura le agregue una lista de Evaluaciones,
tambi茅n modifique a como string la propiedad Alumno en la clase Evaluaciones,

y para cargar las evaluaciones lo hice de la siguiente manera

Y para generar las notas random

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

Yo realice mi soluci贸n al reto de la siguiente manera:
Sin alterar las clases predefinidas escribo el m茅todo 麓CargarEvaluaciones麓, el cual genera una nueva lista del tipo Evaluaci贸n para despu茅s recorrer cada asignatura dentro de cada curso y cada alumno dentro del mismo curso para agregar un ango a mi lista antes declara el retorno del m茅todo 麓Generaci贸nEvaluacionesAleatorias麓 y finalmente cree un nuevo m茅todo est谩tico en la clase Printer para darle un poco de formato a la impresi贸n de todas las evaluaciones. Anexo c贸digo:

private void cargarEvaluaciones()
        {
            List<Evaluacion> evaluaciones = new List<Evaluacion>();
            foreach (Curso curso in Escuela.Cursos)
            {
                foreach (Alumno alumno in curso.Alumnos)
                {
                    foreach (Asignatura asignatura in curso.Asignaturas)
                    {
                        evaluaciones.AddRange( GeneracionEvaluacionesAleatorias( alumno, asignatura) );
                    }
                }
            }
            Printer.ImprimeEvaluaciones( evaluaciones );
        }

 private List<Evaluacion> GeneracionEvaluacionesAleatorias( Alumno alumno, Asignatura asignatura, int numEval = 5)
        {
            List<Evaluacion> evaluacionesAlAzar = new List<Evaluacion>();
            Random rnd = new Random();
            for (int i = 1; i <= numEval; i++)
            {
                int unidad = rnd.Next( 0, 5 );
                float dec = float.Parse(rnd.NextDouble().ToString());
                evaluacionesAlAzar.Add( new Evaluacion{ Alumno = alumno, 		Asignatura = asignatura, Nota = unidad+dec } );
            }
            return evaluacionesAlAzar;
        }
 public static void ImprimeEvaluaciones( List<Evaluacion> evaluaciones )
        {
            foreach (Evaluacion eval in evaluaciones)
            {
                Write($"{eval.Alumno.Nombre} - {eval.Asignatura.Nombre} - {eval.Nota}\n");
            }
        }
private void CargarEvaluaciones()
{
  Random rnd = new Random();
    var Evalua = new List<Evaluaciones>();
    foreach(var curso in Escuela.Cursos)
    {
      foreach(var alum in curso.Alumnos)
      {
        foreach(var cursoasig in curso.Asignaturas)
        {
          float nota= Convert.ToSingle(rnd.Next(1,50))/10;
          Console.WriteLine($"{curso.nombre}, {alum.Nombre} , {cursoasig.nombre} , {nota} ");
          new Evaluaciones{nombre="Periodo1", Alumno=alum, Asignatura=cursoasig, Nota=nota};
        }
      }
      curso.Evaluaciones=Evalua;
    }
}