El gran reto

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

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

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

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

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

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

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

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

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

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

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 …

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

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

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

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

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

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

En la case Alumno, agrego una propiedad Lista de tipo Evaluaciones

En el método CargarEvaluaciones, recorro cada curso, asignatura y alumno, para asignar la lista de evaluaciones.

Yo cree una función “LoadEvanluations” que se encarga de cargar las evaluaciones dentro de cada curso.

Y para generar las 5 calificaciones cree una función encargada de devolver 5 valores float aleatorios.

Lo hice de esta manera.

<        private void CargarEvaluaciones()
        {
            foreach (var curso in Escuela.ListaCursos)
            {
                Console.WriteLine("----------------------------------");
                Random rdn = new Random();
                var evaluacion = from alumno in curso.ListaAlumnos
                                 from asignatura in curso.ListaAsignaturas
                                 select new Evaluacion(curso.Nombre, alumno, asignatura, rdn.Next(5));
                curso.ListaEvaluaciones = evaluacion.ToList();
                foreach (var ev in curso.ListaEvaluaciones)
                {
                    Console.WriteLine(ev.ToString()+"\n");
                }
            }
            
        }> 

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

            Random random = 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 < 5; i++){
                            var evaluacion = new Evaluaciones();
                            evaluacion.Nombre = asignatura.Nombre + " " + curso.Nombre + " " + (i+1);
                            evaluacion.Alumno = alumno;
                            evaluacion.Asignatura = asignatura;

                            decimal mark = random.Next(1, 50) / 10;
            
                            decimal nota = decimal.Round(mark, 1);
                            evaluacion.Nota = (float)nota;
                            evaluaciones.Add(evaluacion);
                        }
                    }
                }
                
                  
            }

            Console.WriteLine("Evaluaciones Cargadas");
            
        }

Toma gran parte de la idea de @brunosendras porque estuve muy trancado, ahora me siento como un fracaso 😔 pero bueno talvez sea normal

private void LoadEvaluations()
        {

            foreach (Course course in school.Courses)
            {

                int[] evNumber = { 1, 2, 3, 4, 5 };
                IEnumerable<Evaluation> evaluationList = from evaluatedStudent in course.Students
                                                         from evaluatedCourseTopic in course.CourseTopics
                                                         from evaluationNumber in evNumber
                                                         select new Evaluation
                                                         {
                                                             Name = $"Evaluacion {evaluationNumber}",
                                                             CTopic = evaluatedCourseTopic,
                                                             Student = evaluatedStudent,
                                                             Grade = RandomFloatGenerator(0.0f, 5.0f)
                                                         };

            }


        }

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(evaluación);
                //Util.Printer.WriteTitle(evaluación.Nombre+" "+evaluación.Nota);
            }
            return evaluaciones;
        }

Implemente de esta manera la “Clase 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)
                            });
                        }
                    }
                }
            }
        }```

Excelente!

Dificil, no me queda claro

yo cree la clase evaluación con la siguiente estructura

using System;


namespace CorEscuela.Entidades
{
    public class Evaluación
    {
        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(“BIENVENIDOS 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;
  }
}

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 “System.Collections.Generic.List” a “List” 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