Resolución del reto

Un recordatorio: para poder utilizar add(), alumno.Evaluaciones debe estar inicializado, en caso contrario da error.

Finalmente estoy confirmando que hay mucha improvisación. Parece un despropósito que de clase en clase aparezcan cosas que no se han hecho, que no se han visto en los videos. En este caso, la clase Alumno no tenia un propiedad Evaluaciones, que “mágicamente” aparece cuando en este video se explica la solución dada por el instructor. Una perdida enorme de tiempo revisando la creacion de las clases. Intento seguir positivo, pero para quienes estamos acá, en fundamentos, realmente es frustrante. un pena que las cosas sean así. Ademas, utiliza nombres que no son los correctos, y en el video no marca un error, como por ejemplo new Evaluacion. Cual clase de llama así?

En este video no salió pero la clase “Alumno” se debe ver asi:

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<Evaluacion> Evaluacion { get; set; }

        //--- CONSTRUCTOR ---
        public Alumno()
        {
            this.UniqueId = Guid.NewGuid().ToString();
            this.Evaluacion = new List<Evaluacion>(){};
        } 
        
    }
}```

No se especificó en el vídeo pero a la clase Alumno se le agregó la propiedad de lista de evaluaciones.

Yo lo agregué a la clase Asignatura.

Por lo demás, casi todo igual salvo la generación del random.

Modelo Datos

Solución

Reto:

private void generarEvaluaciones()
        {
            Random rnd = new Random();
            foreach(var curso in Colegio.Cursos)
            {
                foreach(var materia in curso.Asignaturas)
                {
                    foreach(var estudiante in curso.Alumnos)
                    {
                        float calificacion = (rnd.Next(0, 5) * 1.0f) + (rnd.Next(0, 9) / 10.0f);								
                        var evaluacion = new Evaluacion("Corte1",calificacion,estudiante,materia);
                        WriteLine($"{estudiante.Nombre} - {materia.Nombre} -{evaluacion.Nombre}: {evaluacion.Nota}");
                    }
                }
            }
        }   

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

Para solucionar lo de la nota, lo hice generando un random entre 0 y 50 y casteando la división por 10

Random rand = new Random();
float nota = (float)(rand.Next(0, 50) / 10.0);
WriteLine(nota);

****Todavía podría mejorar un poco mi solución pero al menos cumple, primero añadí una lista de evaluaciones a la clase Curso

Despues crear un metodo para generar las evaluaciones, puedo indicar cuantas evaluaciones se van a generar por materia, por defecto 1 , aqui ademas se llama a un metodo que genera las notas al azar

Para visualizar genere un método que imprime las notas de los alumnos y un resumen del curso y cantidad de alumnos.
Trate de hacer un filtrado en la lista pero es probable que esto este de mas o se pueda mejorar bastante.

Resultado Final

****

Hola amigos acá dejo mi repo con la solución https://github.com/C0deUniverse/DesarrolloDeAplicacionesConAsp.Net_Platzi

Excelente curso, un poco denso pero muy valioso. Solo una observación… seria genial que desde el principio de la clase se hubiera diseñado todo el programa para saber que se iba a codear…Esta última clase existieron modificaciones en las clases y en los atributos como por ejemplo alumno.

Clase Curso

   public class Curso
    {
        public string Nombre { get; set; }
        public string UniqueId { get; private set; }
        public TiposJornadas Jornada { get; set; }
        public List<Asignatura> Asignatura { get; set; }
        public List<Alumno> Alumnos { get; set; }
        public List<Evaluación> Evaluaciones { get; set; }
        public Curso() => UniqueId = Guid.NewGuid().ToString();
        
    }```

Resultado Reto:

Yo implementé al final una función en la clase printer, para poder imprimir la información de la escuela. Ordenada por curso, alumno y materia. Mostrando sus evaluaciones y su promedio por materia.

internal static void ImprimirInformacionEscuela(Escuela escuela)
        {
            DibujarTitulo(escuela.Nombre);
            WriteLine($"{escuela.AñoCreacion}, {escuela.Ciudad}, {escuela.Pais}");
            foreach(var c in escuela.cursos)
            {
                WriteLine($"{c.Nombre} - {c.id}");
                foreach(var a in c.Alumnos)
                {
                    WriteLine($"{a.Nombre} - {a.UniqueId}");
                    foreach(var m in c.Asignaturas)
                    {                        
                        WriteLine($"{m.Nombre}");
                        float promedio = 0;
                        foreach(var e in m.Evaluaciones)
                        {
                            if(e.Alumno.UniqueId==a.UniqueId){
                                WriteLine($"{e.Nombre}: {e.Nota}");
                                promedio+=e.Nota;
                            }    
                        }
                        promedio=promedio/5;                        
                        WriteLine($"Promedio: {promedio}");
                    }
                    DibujarLinea(50);
                }
            }
        }

Para validar sólo los 2 dígitos decimales para la Notade cada Evaluacion yo usé lo siguiente:

(float)Math.Round(GenerarNota(), 2, MidpointRounding.ToEven)

Esta es una opción para el random

var eval = random.Next(0, 50) * 0.1;

Yo lo hice mucho mas corto, meti las asignaturas a cada estudiante, las asignaturas me permiten tener una evaluacion aleatoria entre 1 y 5 y la nota es tambien aleatoria entre 0,0 y 5,0 Easy.

Yo como calculé la nota fue generar un aleatorio entre 0 y 50 y luego dividirlo dentro de 10…

Random rnd = new Random();
float nota = (rnd.Next(0,50)/10);

EN EL RETO coloque la lista de evaluaciones en la clase EscuelaEngine, después todo estaba igual. Me sorprendio que mi análisis estuvo bien.
Con esta clase, ya hice la modificación colocando la lista en la clase Alumnos y bueno este sería el resultado de CargaEvaluaciones():

        private void CargarEvaluaciones()
        {
            List<Evaluaciones>evaluaciones = new List<Evaluaciones>();
            var listaCursos = Escuela.cursos;

            foreach (var curso in listaCursos)
            {
                foreach (var asignatura in curso.Asignaturas)
                {
                    foreach (var alumno in curso.Alumnos)
                    {
                        Random rnd = new Random();
                        for (int i = 0; i < 5; i++)
                        {
                            var nota = rnd.NextDouble()*(5.0)+(0.0);
                            var eva =new Evaluaciones
                            {
                                Alumno = alumno,
                                Asignatura = asignatura,
                                Nota = (float)nota
                            };
                            alumno.Evaluaciones.Add(eva);
                        }
                        
                    }
                }
            }
        }

Yo generé un metodo para generar numeros flotantes:

        public static float RandomFloatGenerator()
        {
            Random randFloat = new Random();
            float randomFloat1 = (float)Math.Round( ( 5 * randFloat.NextDouble() ), 2);
            return randomFloat1;
        }

De esta forma actualicé las evaluaciones de los alumnos despues de haberles asignado las asignatruas a cada alumno

Para la nota usé una operación para que se mantuviera en el rango deseado

Random rnd = new Random(); 
            escuela.Cursos.ForEach(cc=> cc.Alumnos
            .ForEach(al=>al.Asignaturas
            .ForEach(a=>a.Evaluaciones
            .ForEach(ev=>{ev.Nota = (float)(0.0+(5.0-0.0)*rnd.NextSingle());ev.Alumno=al;ev.Asignatura=a;}))));

Si imprimen las calificaciones puede que la semilla del random les duplique las notas/calificaciones por curso.

Random rndint = new Random();
int salt = rndint.Next(1, 1000);
var rnd = new Random(System.Environment.TickCount * salt);

Mi Repo en GitHub

public List<Evaluations> LoadEvaluations(){
            List<Evaluations> evList = new List<Evaluations>();
            foreach (var course in School.Courses){
                foreach (var courseClass in course.CoursesList){
                    foreach (var student in course.StudentsList){
                        var rnd = new Random();
                        for (int i = 0; i < 5; i++){
                            var ev = new Evaluations
                            {
                              CourseClass = courseClass,
                              Name = $"{courseClass.Name} Ev# {i+1}",
                              Qualification = (float)(5 * rnd.NextDouble()),
                              Student = student
                            };
                            evList.Add(ev);
                        }
                    }
                }
            }
            return evList;
        }

Reto completado!!!
Mi solución en Github

Mi solución fue casi igual a la que mostró el profesor

Dios te ama

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

        foreach (var curso in Escuela.Cursos)
        {
            var evaluaciones = from alumno in curso.Alumnos
                               from asignatura in curso.Asignaturas
                               from e in eval
                               select new Evaluacion { Alumno = alumno, Asignatura = asignatura, Nota = 5.0f * (float)new Random().NextDouble(), Nombre = $"{e} Evaluacion de {asignatura.Nombre} de {alumno.Nombre}" };
            curso.Evaluaciones = evaluaciones.ToList();
        }
    }

Mi solución utilizando producto cartesiano.

 private void UploadEvaluations()
        {
            var evaluations = new List<Evaluation>();
            var evaluationTypes = new List<string> { "First", "Second", "Third", "Fourth", "Fifth" };

            Random rnd = new Random();
            float score = (float)(rnd.NextDouble() * 5);

            foreach (var course in School.Courses)
            {

                var evaluationsByCourse = from student in course.Students
                                          from subject in course.Subjects
                                          from evaluation in evaluationTypes
                                          select new Evaluation { Name = evaluation, Student = student, Subject = subject, Score = score };

                evaluations = evaluationsByCourse.ToList();
            }
        }

veo que se le puede hacer mejoras

            foreach (var curso in Escuela.Cursos)
            {
                foreach (var alumno in curso.Alumnos)
                {
                    alumno.evaluaciones = curso.Evaluaciones;
                }
            }
            foreach (var curso in Escuela.Cursos)
            {
                foreach (var alumno in curso.Alumnos)
                {
                    foreach (var evaluacion in alumno.evaluaciones)
                    {
                        evaluacion.Nota = generarNotasAzar();
                    }
                }
            }
            }
        }

Bueno en mi Caso yo le asocie a cada Alumno de cada Curso sus respectivas evaluaciones por sus materias y el método que utilice fue este:

private List<Evaluacion> GenerarEvaluacionalAzar()
        {
            List<Asignatura> asignaturas = new List<Asignatura>() { };
            List<Alumno> alumnos = new List<Alumno>() { };
            List<Evaluacion> listaEvaluaciones = new List<Evaluacion>() { };
            var id = string.Empty;


            foreach (var curso in Escuela.Cursos)
            {
                asignaturas = curso.Asignaturas;
                alumnos = curso.Alumnos;
                id = curso.Nombre;
                var ListaEval = from asignatura in asignaturas
                                from alumno in alumnos
                                select new Evaluacion() { Nombre = $"Evaluación de {asignatura.Nombre} {id}", Asignatura = asignatura, Alumno = alumno, Nota = GetRandomNumber(0.0, 5.0) };
                listaEvaluaciones.AddRange(ListaEval.OrderBy(delegate (Evaluacion eval) { return eval.Alumno.UniqueId; }).ToList());
            }
            return listaEvaluaciones;

        }

        private void CargarEvaluaciones()
        {
            var eval = new List<Evaluaciones>();
            foreach (var curso in Escuela.Cursos)
            {
                foreach (var alumno in curso.Alumnos)
                {
                    foreach (var asignatura in curso.Asignaturas)
                    {
                        Random rnd = new Random();
                        float notaRandom = rnd.Next(0, 5);
                        eval.Add(new Evaluaciones { Alumno = alumno, Asignatura = asignatura, Nota= notaRandom });
                    }
                }
            }
            Evaluaciones = eval.ToList();

        }

👏🏽

Muy buen curso

Cometí el error de querer recorrer con un “foreach” las asignaturas, cuando lo primero era de recorrer los cursos ya que estos inicializaban las asignaturas.

Pero por otro lado, me resulto un excelente curso el cual me ayudó a iniciar en C#, además, podar contar con un buen maestro que de vez en cuando hacía chistes. Un gusto ✨-

Gracias Juan

Lo woo del curso fueron lo de Linq, ya que la mayoria de soluciones seamos nuevos o conocedores quizo intentarlo.

Totalmente diferente :v

Les dejo mi solución del reto

private void CargarEvaluaciones()
{
    Random rnd = new Random();
    foreach (Curso curso in Escuela.Cursos)
    {
        string[] nombres = { "Prueba 1", "Prueba 2", "Prueba 3", "Prueba 4", "Prueba 5" };
        var listaE = from al in curso.Alumnos
                     from asig in curso.Asignaturas
                     from n in nombres
                     select new Evaluacion(nombre: n, alumnoId: al.UniqueId, asignaturaId: asig.UniqueId, nota: (rnd.NextDouble() * 5).ToString("0.0"));
        curso.RegistroDeEvaluaciones.AddRange(listaE);
    }
}

Por que se guardan las evaluaciones en el alumno?, osea si la evaluación ya tiene un atributo de cual es el alumno entonces acaso no es esto repetitivo, ademas de esta forma se complica saber en que curso se realizo la evaluación en caso de ser necesaria ya que el estudiante no tiene ningún atributo del curso al que pertenece, creo que seria mejor guardar esta lista como un atributo de la clase Curso.
que opinan al respecto?

Importante recordar que al usar un método para generar números aleatorios como el siguiente

 var rnd = new Random(System.Environment.TickCount);
 Nota =  (float)Math.Round((5 * rnd.NextDouble()),1);

podemos obtener las series de números aleatorios se repiten en cada grupo de evaluaciones, por lo que las notas de los alumnos podrían ser las mismas que las de sus compañeros.

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

 private void LoadEvaluations()
        {
            string[] nombreEvaluacion = { "Evaluacion " };
            string[] numeros = { "Uno ", "Dos ", "Tres", "Cuatro ", "Cinco" };

            //List of evaluation class to load an each subject
            List<Evaluacion> evaluaciones = new List<Evaluacion>();
                        
            UInt16 iteratorArray = 0;

            foreach(var curso in escuela.Cursos)
            {
                foreach(var alumno in curso.Alumno)
                {
                    foreach(var asing in curso.Asignaturas)
                    {
                        var nmEvaluacones = from nEval in nombreEvaluacion
                                            from num in numeros
                                            select new string(nEval + num);

                        for(UInt16 i = 0; i < 5; i++)
                        {
                            float nota = (float)((new Random().NextDouble()) * 5.0);
                            evaluaciones.Add(new Evaluacion()
                            {
                                Alumno_ = alumno,
                                NombreEval = nmEvaluacones.ElementAt(i),
                                Nota = nota

                            });
                        }
                        asing.Evaluaciones = evaluaciones;
                                                                                                            
                    }                    
                }
            }
        }```

Excelente!

No pude resolverlo

En la implementación del generador de números aleatorios, nunca tomaría el valor de 5? dado que la documentación dice mayor o igual que 0 y menor que 1

private void CargarEvaluaciones()
{
foreach (Curso curso in Escuela.Cursos)
{
var evaluacionesCurso = new List<Evaluacion>();
foreach (Alumno alumno in curso.Alumnos)
{
foreach (Asignatura asignatura in curso.Asignaturas)
{
var ev = new Evaluacion();
ev.Asignatura = asignatura;
ev.Alumno = alumno;
ev.Nota = GenerarNotaAleatoria();
evaluacionesCurso.Add(ev);
} // foreach Asignatura asignattura in curso.Asignaturas
} // foreach Alumno alumno in curso.Alumnos
curso.Evaluaciones = evaluacionesCurso;
} // foreach Curso curso in Escuela.Cursos
} // CargarEvaluaciones

    private double GenerarNotaAleatoria()
    {
        Random rand = new Random();
        int max = 5;
        double min = rand.NextDouble();
        double nota = Convert.ToDouble(Math.Round((max * min), 1));
        return nota;
    } // GenerarNotaAleatoria

<code>

Buenas clases

me pareció mas apropiado utilizar la lógica de linq para combinar listas y así poder multiplicar los resultados

mi escuela engine quedo de esta forma:
public class EscuelaEngine
{
public Escuela Escuela { get; set; }

    public EscuelaEngine()
    {
        
    }

  

    public void Inicializar()
    {

        Entidades.Escuela escuela = (Escuela) = new Entidades.Escuela("Jose .J Arosemena", 1988,
            ciudad: "Panamá",
            país: "Panamá",
            tipoescuela: Entidades.TiposEscuela.Primaria
        );

        List<Curso> listaCursos = InicializarCursos();

        AsignarCursos(escuela, listaCursos);
        AsignarAsignaturas();
        AsignarAlumnos();
        AsignarEvaluaciones();

    }

    private void AsignarEvaluaciones()
    {
        string[] nombrenotas = { "Test1","Test2","Test3","Quiz","ExamenFinal" };

        foreach (var curso in Escuela.Cursos)
        {
            
            var listaEvaluaciones = from asignatura in curso.Asignaturas
            from estudiante in curso.Alumnos
            from nomnotas in nombrenotas
            select new Evaluaciones { Nombre = nomnotas, Alumno = estudiante, Asignatura = asignatura, Nota = randomnota() };

            foreach (Evaluaciones ev in listaEvaluaciones)
            {
                curso.Evaluaciones.Add(ev);
                    }
        }

    }

    private float randomnota()
    {
        float resp ;
        Random random = new Random();
         resp = (float)random.Next(0, 5) + (float)Math.Round(random.NextDouble(),2);
        return resp;
    }

    private List<Alumno> CrearAlumnos(int numalumnos)
    {
        string[] nombreF = { "Ana", "Diana", "Liz" };
        string[] segundonombreF = { "Maria", "Lucrecia", "Carolina", "Adriana" };
        string[] apellido = { "Arosemena", "Juarez", "Robles", "Solis", "Samaniego" };
        string[] segundoapellido = { "Cortez", "Rios", "Aguilar", "Moreno", "Castillo" };

        string[] nombreM = { "Elias", "Juan", "Jose" };
        string[] segundonombreM = { "Felipe", "Carlos", "Diego","Daniel" };

        var listaAlumnosF = from n1 in nombreF
                            from n2 in segundonombreF
                            from a1 in apellido
                            from a2 in segundoapellido
                            select new Alumno { Nombre = $"{n1} {n2} {a1} {a2}" };

        var listaAlumnosM = from n1 in nombreM
                            from n2 in segundonombreM
                            from a1 in apellido
                            from a2 in segundoapellido
                            select new Alumno { Nombre = $"{n1} {n2} {a1} {a2}" };

        List<Alumno> listaAlumnos = new List<Alumno>();
        listaAlumnos.AddRange(listaAlumnosF);
        listaAlumnos.AddRange(listaAlumnosM);

        return listaAlumnos.OrderBy(x => x.UniqueId).Take(numalumnos).ToList();
    }

    private void AsignarAlumnos()
    {
        foreach (var curso in Escuela.Cursos)
        {
            Random random = new Random();
            int numrandom = random.Next(10,45);                  
            curso.Alumnos = CrearAlumnos(numrandom);
        }

        }

    private void AsignarAsignaturas()
    {
        foreach(var curso in Escuela.Cursos )
        {
            List<Asignatura> listasignatura = new List<Asignatura>()
            {
                new Asignatura {Nombre="Matemáticas"},
                new Asignatura {Nombre="Educacion Física"},
                new Asignatura {Nombre="Castellano"},
                new Asignatura {Nombre="Ciencias Naturales"},
                new Asignatura {Nombre="Español"}
            };
            curso.Asignaturas.AddRange(listasignatura);

        }
    }

    public List<Curso> InicializarCursos()
    {
        List<Curso> listaCursos = new List<Curso>
        {
            new Curso { Nombre = "101", Jornada = TiposJornadas.Mañana },
            new Curso { Nombre = "201", Jornada = TiposJornadas.Mañana },
            new Curso { Nombre = "301", Jornada = TiposJornadas.Mañana },
            new Curso { Nombre = "401", Jornada = TiposJornadas.Tarde },
            new Curso { Nombre = "501", Jornada = TiposJornadas.Tarde }
        };

        return listaCursos;
    }

    public bool AsignarCursos(Escuela escuela, List<Curso> Cursos)
    {
        bool respuesta = false;
        escuela.Cursos = Cursos;

        return respuesta;
    }
    public bool AsignarCursos(Escuela escuela, Curso Curso)
    {
        bool respuesta = false;
        escuela.Cursos.Add(Curso);

        return respuesta;
    }

    public void ImprimirCusosEscuela()
    {
        Printer.WriteTitle("Cursos de la Escuela");
       
        if (Escuela?.Cursos != null)
        {
            foreach (var curso in Escuela.Cursos )
            {
                Console.WriteLine($"Nombre: \"{curso.Nombre}, ID:\"{curso.UniqueId}\" ");

                Printer.WriteTitle($"Evaluaciones del Cursos \"{curso.Nombre}\"");
                string oldasignatura = "";
                foreach (var evaluacion in curso.Evaluaciones.OrderBy(x=>x.Alumno.Nombre).ThenBy(x=>x.Asignatura.UniqueId))
                {
                    if (oldasignatura != evaluacion.Asignatura.UniqueId)
                    {
                        Console.WriteLine(System.Environment.NewLine);
                        Printer.DigujarLinea(50);
                        Console.WriteLine($"    Alumno: \"{evaluacion.Alumno.Nombre}\", Asignatura: \"{evaluacion.Asignatura.Nombre }\" ");
                        Printer.DigujarLinea(50);
                    }
                        Console.WriteLine($"         {evaluacion.Nombre} = {evaluacion.Nota} ");

                    oldasignatura = evaluacion.Asignatura.UniqueId;

                }

               
            }
            Printer.WriteTitle("Termina Impresion de Cursos");
        }
    }

   
}

Aquí les dejo mi solución para este reto que se me ocurrió antes de ver la solución propuesta por el profesor:

Incluí la propiedad de Evaluaciones dentro de la clase Curso para así cargar la lista por curso, mediante el método CargarEvaluaciones().

**EscuelaEngine.CargarEvaluaciones() **

 private void CargarEvaluaciones()
        {
            
            foreach (var curso in Escuela.Cursos)
            {
                //Inicializar la lista de evaluaciones
                var listaEvaluaciones = new List<Evaluacion>();
                
                foreach (var asignatura in curso.Asignaturas)
                {
                    for (int i = 1; i < 5; i++)
                    {
                        //Orden de la evaluacion
                        int nEvaluacion = i;

                        Random rndInt = new Random(); //Inicializar parte entera de la nota
                        Random rndDec = new Random(); //Inicializar parte entera de la decimal
                        Random rndModelo = new Random(); //Inicializar numero de evaluacion

                        foreach (var alumno in curso.Alumnos)
                        {
                            //Asignacion de valores para nota de evaluacion
                            float NotaEntero = rndInt.Next(0,5);
                            double NotaDecimal = rndDec.NextDouble();

                            float NotaAlumno = NotaEntero + Convert.ToSingle(NotaDecimal);
                            
                            //Asignacion de valores para numero de evaluacion
                            int nModelo = rndModelo.Next(0,30);

                            //Extracción de iniciales de la asignatura
                            String InicialesAsignatura = (asignatura.ToString()).Substring(0, Length);

                            //Cargar evaluación a la lista 
                            listaEvaluaciones.Add(new Evaluacion() { Nombre = InicialesAsignatura + " Periodo " + i.ToString() + " Modelo " + nModelo , Alumno = alumno, Asignatura = asignatura, Nota = NotaAlumno });
                            };
                    }
                      
                }
                
                //Cargar lista de evaluaciones en el curso
                curso.Evaluacion = listaEvaluaciones;
            }
        }
        

Para comprobar los resultados modifiqué el método ImprimirCursosEscuela de la clase Program.

private static void ImprimirCursosEscuela(Escuela escuela)
        {
            Printer.DibujarLinea(20);
            Printer.WriteTitle("Cursos de la Escuela");
            Printer.DibujarLinea(20);

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

Una muestra del resultado es la siguiente:

Muchas gracias, aunque ya llevo algunos años trabajo con .net me sirvió para reforzar conceptos.

Gracias a este curso, se usar el debugger y me ahorro poniendo los Console.writleline para depurar xd

La forma en que resolví el reto fue muy similar a la del instructor, donde si hice algo totalmente diferente (y poco óptimo) fue la generación del la nota).

1ro - Genere un numero entero de 0 a 5 y lo converti a double,
2do - Genere un numero entre 0.0 y menor a 1.0
3ro - Sume ambos valores, se redondea el resultado a 1 digito y lo asigne a como Nota.
4to - Como la nota tiene un probabilidad de ser mayor a 5, por lo tanto valide que si el valor es mayor a 5 asigne por default el valor de 5.0

eval.Nota = (float)Math.Round((double)rnd.Next(0, 5) + rnd.NextDouble(), 1);
if (eval.Nota > 5)
    eval.Nota = 5;

Use el enfoque linq, me parecio mas sencillo de entenderlo así

private void CargarEvaluaciones()
        {
            foreach (var curso in Escuela.Cursos)
            {
                string[] evaluaciones = { "Examen 1", "Examen 2", "Examen 3", "Examen 4", "Examen 5" };

                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 = RandomRedondeado()
                                        };
                curso.Evaluaciones = listaEvaluaciones.ToList();
            }
            
        }

        private float RandomRedondeado()
        {
            Random rnd = new Random();
            return (float)Math.Round((rnd.NextDouble() * 10.0) % 5.0);
        }
<code>

Yo cargué cada evaluacion a su respectiva asignatura, ya que una evaluacion pertenece a una asignatura.

Para generar el numero aleatorio use este formula: rnd.NextDouble() * (max - min) + min)

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 = (float)(rnd.NextDouble() * (5.0 - 1.0) + 1.0)
                            });
                        }
                    }
                }
            }
        }

les comparto lo que no me funciono generaba 150 examenes no logre realizarlo de manera correcta

 private void GenerateEvaluation()
        {
            foreach (var curso in school.Courses)
            {
                string[] evaluations = {"1", "2", "3", "4", "5"};
                Random rdon = new Random();
                int min = 0;
                int max = 4;
                var numRandom = (rdon.NextDouble()* (max - min + 1)) + min;
                var listEvaluation = from student in curso.students
                                     from subject in curso.subjects
                                     from nroeva in evaluations
                                     select new Evaluation(){name = $"Evaluation {nroeva}", student = student, subject = subject, note = (float) numRandom};
                curso.evaluations = listEvaluation.ToList();
            }
           

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

Una solución efectiva

Lo que más aprendí de este curso fue a usar expresiones lambda y Linq.

Corregí mi código… Parecería que esta bien…

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

                    c.Evaluaciones = carEv.ToList();

                }```

Bueno, me siento un poco decepcionado conmigo mismo. Sinceramente no pude conseguir la solución por mi cuenta. Tuve que básicamente copiarme de otras soluciones. Aunque viendo este vídeo, la solución para mi tiene muchísimo más sentido…

Mi código quedó muy diferente,en especial porque la estructura de mi escuela es diferente
,pero, me la pasé genial escribiéndolo, investigando lo que necesitaba para completarlo, tardé mucho
pero al final lo logré y aprendí muchísimo, aunque estoy seguro de que hay mejores maneras de
escribirlo y optimizarlo pues me siento contento de haberlo logrado jaja 😄

////funcion (metodo) que despues se invoca (en AssignEvaluationsData) 
        ///para generar un array con datos aleatorios de tipo double. (rerorna 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++;
                        }
                    }
                }
            }
        }

La verdad me perdí un poco generando la solución, pero una vez viendo esta clase le entendí mucho mejor.
Gracias!

A la solución implementada le agregué las evaluaciones desde un array, donde dependiendo de la asignatura, se generan evaluaciones diferentes. Por ejemplo, la asignatura Biologia, tiene una evaluaciòn llamada laboratorio, la cual solo se genera para dicha asignatura.

También le agregué un parametro extra al método imprimir titulo, para agregarlo color al texto, dejo el código al final.

Program.cs

using System;
using System.Collections.Generic;
using CoreEscuela.Entidades;
using CoreEscuela.Util;
using static System.Console;

namespace CoreEscuela
{
    class Program
    {
        static void Main(string[] args)
        {
            EscuelaEngine Engine = new EscuelaEngine();
            Engine.Inicializar();
            Printer.PrintTitle("Bienvenido a la escuela", ColoresConsola.Verde);

            IprimirCursos(Engine.Escuela);
            ImprimirEstudiantes(Engine.Escuela);
        }

        /// <summary>
        /// Imprime el nombre del curso y uniqueId de cada curso de la clase Escuela
        /// </summary>
        /// <param name="escuela"></param>
        private static void IprimirCursos(Escuela escuela)
        {
            Printer.PrintTitle("Listado de cursos escuela", ColoresConsola.Verde);

            if (escuela?.Cursos != null)//? valida si el objeto es nulo
            {
                foreach (var curso in escuela.Cursos)
                {
                    WriteLine($"Curso: {curso.Nombre}, id: {curso.UniqueId}");
                }
            }
            else
            {
                Printer.PrintAdvertising("No hay cursos disponibles.");
            }
        }

        private static void ImprimirEstudiantes(Escuela escuela)
        {
            Printer.PrintTitle("Listado de estudiantes y notas", ColoresConsola.Azul);

            if (escuela?.Cursos != null)//? valida si el objeto es nulo
            {
                foreach (var curso in escuela.Cursos)
                {
                    if (curso.Alumnos.Count > 0)
                    {
                        ImprimirEvaluacionesEstudiante(curso.Alumnos);
                    }
                    else
                    {
                        Printer.PrintAdvertising("No hay alumnos disponibles.");
                    }
                }
            }
            else
            {
                Printer.PrintAdvertising("No hay cursos disponibles.");
            }
        }

        /// <summary>
        /// Imprime las evaluaciones de cada alumno según un listado de alumnos.
        /// </summary>
        /// <param name="alumnos"></param>
        private static void ImprimirEvaluacionesEstudiante(List<Alumno> alumnos)
        {
            foreach (var alumno in alumnos)
            {
                
                Printer.PrintTitle($"Evaluaciones realizadas por {alumno.Nombre}", ColoresConsola.Verde);

                if (alumno.Evaluaciones != null)
                {
                    foreach (var evaluacion in alumno.Evaluaciones)
                    {
                        WriteLine($"Asignatura: {evaluacion.Asignatura.Nombre}; Evaluación: {evaluacion.Nombre}; Nota: {evaluacion.Nota.ToString("0.00")}.");
                    }
                }
                else
                {
                    Printer.PrintAdvertising("No hay evaluaciones disponibles.");
                }
            }
        }
    }
}

EscuelaEngine.cs

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

namespace CoreEscuela
{
    public class EscuelaEngine
    {
        public Escuela Escuela {get; set;}

        public void Inicializar()
        {
            Escuela = new Escuela("Platzi Academy", 1996, TiposEscuela.Primaria, pais: "Chile", ciudad: "Santiago");

            CargarCursos();
            CargarAsignaturas();
            CargarEvaluaciones(5);
        }

        private void CargarEvaluaciones(int cantidadEvaluaciones)
        {
            if (cantidadEvaluaciones > 0)
            {
                string[] evaluacionesGenerales = {"Exámen escrito", "Exposición", "Taller", "Foro", "Informe", "Exámen oral"};
                string[] evaluacionesBiologia = {"Exámen escrito", "Exposición", "Taller", "Foro", "Informe", "Exámen oral", "Laboratorio"};
                string[] evaluacionesEducacionFisica = {"Exámen escrito", "Exposición", "Ejercicios", "Informe", "Equilibrio", "Elasticidad"};

                foreach (var curso in Escuela.Cursos)
                {
                    foreach (var asignatura in curso.Asignaturas)
                    {
                        foreach (var alumno in curso.Alumnos)
                        {
                            for (int i = 0; i < cantidadEvaluaciones; i++)
                            {
                                Evaluacion evaluacion;

                                switch (asignatura.Nombre)
                                {
                                    case "Biología":
                                        evaluacion = new Evaluacion(nombre:evaluacionesBiologia[i],
                                                                    alumno:alumno,
                                                                    asignatura:asignatura,
                                                                    nota:GenerarNotaAleatoria());
                                    break;
                                    case "Educación Física":
                                        evaluacion = new Evaluacion(nombre:evaluacionesEducacionFisica[i],
                                                                    alumno:alumno,
                                                                    asignatura:asignatura,
                                                                    nota:GenerarNotaAleatoria());
                                    break;
                                    default:
                                        evaluacion = new Evaluacion(nombre:evaluacionesGenerales[i],
                                                                    alumno:alumno,
                                                                    asignatura:asignatura,
                                                                    nota:GenerarNotaAleatoria());
                                    break;
                                }

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

        private void CargarAsignaturas()
        {
            foreach (var curso in Escuela.Cursos)
            {
                List<Asignaruta> listaAsignaturas = new List<Asignaruta>() {
                    new Asignaruta{Nombre = "Matemáticas"},
                    new Asignaruta{Nombre = "Biología"},
                    new Asignaruta{Nombre = "Castellano"},
                    new Asignaruta{Nombre = "Educación Física"}
                };
                curso.Asignaturas = listaAsignaturas;
            }
        }

        private List<Alumno> CargarAlumnos(int cantidadAlumnos)
        {
            string[] nombresIniciales = { "Alba", "Felipa", "Eusebio", "Farid", "Donald", "Alvaro", "Nicolás" };
            string[] apellido = { "Ruiz", "Sarmiento", "Uribe", "Maduro", "Trump", "Toledo", "Herrera" };
            string[] nombreSegundarios = { "Freddy", "Anabel", "Rick", "Murty", "Silvana", "Diomedes", "Nicomedes", "Teodoro" };

            var listaAlumnos = from n1 in nombresIniciales
                               from n2 in nombreSegundarios
                               from a1 in apellido
                               where a1 != "Maduro"
                               select new Alumno() { Nombre =$"{n1} {n2} {a1}" };
            
            return listaAlumnos.OrderBy(alumno => alumno.UniqueId).Take(cantidadAlumnos).ToList();
        }

        private void CargarCursos()
        {
            Escuela.Cursos = new List<Curso>() {
                new Curso { Nombre = "101", TipoJornada = TiposJornada.Vespertina},
                new Curso { Nombre = "201", TipoJornada = TiposJornada.Diurna},
                new Curso { Nombre = "301", TipoJornada = TiposJornada.Nocturna},
            };

            Random random = new Random();
            foreach (var curso in Escuela.Cursos)
            {
                int cantRandom = random.Next(7, 14);
                curso.Alumnos = CargarAlumnos(cantRandom);
            }
        }

        private float GenerarNotaAleatoria()
        {
            Random random = new Random(System.Environment.TickCount);
            return (float)(5 * random.NextDouble());
        }
    }
}

Printer.cs

using System;
using static System.Console;

namespace CoreEscuela.Util
{
    public static class Printer
    {
        public static void PrintTitle(string title, ColoresConsola color)
        {
            System.ConsoleColor consoleColor = new System.ConsoleColor();

            switch (color)
            {
                case ColoresConsola.Amarillo:
                    consoleColor = ConsoleColor.Yellow;
                    break;
                case ColoresConsola.Azul:
                    consoleColor = ConsoleColor.Blue;
                    break;
                default:
                    consoleColor = ConsoleColor.Green;
                    break;
            }

            var line = "".PadLeft(title.Length, '='); 
            Console.ForegroundColor = consoleColor;

            WriteLine(line);
            WriteLine(title);
            WriteLine(line);

            Console.ResetColor();
        }

        public static void PrintAdvertising(string title)
        {
            var line = "".PadLeft(title.Length, '='); 
            Console.ForegroundColor = ConsoleColor.Yellow;

            WriteLine(title);

            Console.ResetColor();

        }
    }
}

En la linea 46 es posible que genere un numero aleatorio mayor a 5 ?

Adjunto el repositorio de la solución que he trabajado:

https://github.com/jldamians/net-core/tree/master/csharp/first-stage

No sé si cómo lo hice yo es lo más correcto, según yo sí, pero espero que alguien me diga si sí o si no xd.
En lugar de implementar la clase Evaluaciones y asignar las materias a cada curso yo asigné las asignaturas a cada alumno y dentro de la clase Asignatura agregué un nuevo atributo llamado “Nota” donde con ayuda del constructor le daba un valor cada vez que se creaba un objeto Asignatura.

 public static double[] GenerateGrades()
           {
                 Random rnd = new Random();
                 double[] grades = new double[5]; 
                 for (int i = 0; i < 5; i++)
                 {
                     double randomnum = 5 + (rnd.NextDouble() *(0.0 - 5.0));
                     randomnum = Math.Round(randomnum, 2);
                     grades[i] = randomnum;
                 }

                 return grades;
           }

        private static List<Evaluation> LoadEvaluations()
        {
              var evaluationsList = from course in School.Courses
                                    from student in course.Students
                                    from subject in course.Subjects
                                    select new Evaluation
                                           {
                                                 Name = $"Evaluation of {subject.Name}",
                                                 Student = student,
                                                 Subject = subject,
                                                 Grades = GenerateGrades()
                                           };
              
             return evaluationsList.ToList();  
        }

Mi manera de hacerlo, me ayudé en la parte final donde personalizo los datos para cada estudiante. Lo demás lo pude hacer solo.

private void CargarEvaluaciones()
        {
            List<Evaluaciones> listaEvaluaciones = new List<Evaluaciones>(){
                new Evaluaciones{Nombre="Parcial 1"},
                new Evaluaciones{Nombre="Parcial 2"},
                new Evaluaciones{Nombre="Parcial 3"},
                new Evaluaciones{Nombre="Parcial 4"},
                new Evaluaciones{Nombre="Examen final"}
            };

            Random rndm = new Random();

            foreach (Curso curso in Escuela.Cursos)
            {
                foreach (Asignatura asignatura in curso.Asignaturas)
                {
                    asignatura.Evaluacion = listaEvaluaciones;

                    foreach (Evaluaciones evalasign in listaEvaluaciones)
                    {
                        evalasign.Asignatura = asignatura;
                    }

                    foreach (Alumno alumno in curso.Alumnos)
                    {
                        alumno.Evaluacion = listaEvaluaciones;
                        foreach (Evaluaciones eval in alumno.Evaluacion)
                        {
                            eval.Nota = (float) ( 5 * rndm.NextDouble() );
                            eval.Nombre = eval.Nombre + $" {asignatura.Nombre}";
                            eval.Alumno = alumno;
                        }
                    }
                }
            }
        }```

Les comparto mi solución. Es parecida a la solución del profesor pero yo utilizo un arreglo para generar nombres aleatorios de la evaluación y también utilizo la función next(0,50) para generar la nota aleatoria entre 0 y 50, lo casteo a float y lo divido en 10 para tener la nota entre 0.0 y 5.0

string[] choseExamName = {"Quiz", "Parcial", "Evaluación", "Exposicion", "Taller",
"Examen" ,"Examen sorpresa", "Quiz sorpresa"};
Random Rand = new Random();
int NumRand;
foreach (var curso in Escuela.Cursos)
{
    foreach (var stdnt in curso.Estudiantes)
    {
        stdnt.Evacluaciones = new List<Evaluaciones>();
        foreach (var sgntra in curso.Asignaturas)
        {
            for (int i = 0; i < 5; i++)
            {
                NumRand = Rand.Next(0, choseExamName.Length - 1);
                stdnt.Evacluaciones.Add(new Evaluaciones
                {
                    Nombre = $"Nota {i + 1}: {choseExamName[NumRand]} de {sgntra.Nombre}",
                    Estudiante = stdnt,
                    Asignatura = sgntra,
                    Nota = (float)Rand.Next(0, 50) / 10
                });
            }
        }
    }
}

Lo más difícil fue comprender cómo C# entiendo los objetos y como los asigna, ya que siempre me tiraba el error de null reference pero al final comprendí cómo hacerlo, ahora me falta hacerlo eficiente y siguiendo POO

private void CargarEvaluaciones()
        {
           foreach (var curso in Escuela.Cursos)
            {
                 Random rnd = new Random();
                 string[] nomEva = { "Parcial 1", "Parcial 2", "Parcial 3", "Catedra", "Examen"};
                 var lista = from asg in curso.Asignatura
                             from alu in curso.Alumno
                             from nom in nomEva
                             select new Evaluaciones{Nombre=nom,Alumno=alu,Asignatura = asg, Nota = GetRandomNumber()};
            }     
        }

        public float GetRandomNumber()
        { 
            Random random = new Random();
            return (float) (5 * random.NextDouble());
        }

Muy buen curso y divertido!!!

Reto comprendido:

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

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

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

No me acorde del nombre aleatorio … 😦

Clase EscuelaEngine:

        public void Inicualizar()
        {
            Escuela = new Escuela("Platzi academi", 2012, TiposEscuela.Primaria, ciudad: "Bogota", pais: "Colombia");
            CargarCursos();
            CargarAsignaturas();
            CargarEvaluación();
        }

        private void CargarEvaluación()
        {    
            foreach (var curso in Escuela.Cursos)
            {
                curso.Evaluaciones = new List<Evaluación>();
                foreach (var alumno in curso.Alumnos)
                {
                    foreach (var asignarura in curso.Asignatura)
                    {
                        curso.Evaluaciones.AddRange(GenerarEvaluación(curso, alumno, asignarura));                                                
                    }
                }
            }

        }

        private List<Evaluación> GenerarEvaluación(Curso curso, Alumno alumno, Asignatura asignarura)
        {
            Random random = new Random();
            List<Evaluación> listaEvaluciones = new List<Evaluación>();
            for (int i = 0; i < 5; i++)
            {
                listaEvaluciones.Add(new Evaluación{
                    Nombre = $"Parcual {i+1}",
                    Alumno = alumno,
                    Asignatura = asignarura,
                    Nota = Convert.ToSingle(random.Next(0,5) + random.NextDouble())
                });
            }
            
            return listaEvaluciones;
        }

using System;
using System.Collections.Generic;
using System.Linq;

namespace CoreEscuela.Entidades
{
    public class EscuelaEngine
    {
        public EscuelaEngine(Escuela escuela)
        {
            this.Escuela = escuela;

        }
        public Escuela Escuela { get; set; }
        public EscuelaEngine()
        {
            Escuela = new Escuela("Platzi Academy", 2012, TiposEscuela.Primaria,
                        país: "Colombia", ciudad: "Bogotá"
                        );
        }
        public void Inicializar()
        {
            Escuela = new Escuela("Platzi Academy", 2012, TiposEscuela.Primaria,
                        país: "Colombia", ciudad: "Bogotá"
                        );
            CargarCursos();
            CargarAsignaturas();
        }

        private List<double> Notas(int numeroEvaluaciones = 5)
        {
            Random rnd = new Random();
            List<double> evaluaciones = new List<double>();
            for (int i = 0; i < numeroEvaluaciones; i++)
            {
                double calificacion = Math.Round((rnd.NextDouble() * 5), 1);
                evaluaciones.Add(calificacion);
            }
            return evaluaciones;
        }

        private void CargarAsignaturas()
        {
            foreach (var curso in Escuela.Cursos)
            {
                List<Asignatura> listaAsignaturas = new List<Asignatura>(){
                    new Asignatura{Nombre="Matematicas"},
                    new Asignatura{Nombre="Educación Física"},
                    new Asignatura{Nombre="Castellano"},
                    new Asignatura{Nombre="Ciencias Sociales"}
                };
                curso.Asignaturas = listaAsignaturas;
            }
        }
        private List<Alumno> GenerarAlumnosAlAzar(int cantidad)
        {
            string[] nombre1 = { "Alba", "Malcolm", "Resse", "Dewey", "Meg" };
            string[] apellido1 = { "Kasachov", "Kurnikova", "Disney", "Covid", "Wilkerson" };
            string[] nombre2 = { "Lucas", "Bugs", "Pyton", "Peter", "Lois", "Brian" };

            var listaAlumnos =
            from n1 in nombre1
            from n2 in nombre2
            from a1 in apellido1
            select new Alumno { Nombre = $"{a1} {n1} {n2}" };
            List<Alumno> listaAlumnosCurso = listaAlumnos.OrderBy((al) => al.UniqueId).Take(cantidad).ToList();
            List<Asignatura> listaAsignaturas = new List<Asignatura>(){
                    new Asignatura{Nombre="Matematicas",Calificaciones=Notas()},
                    new Asignatura{Nombre="Educación Física",Calificaciones=Notas()},
                    new Asignatura{Nombre="Castellano",Calificaciones=Notas()},
                    new Asignatura{Nombre="Ciencias Sociales",Calificaciones=Notas()}
                };
            foreach (var Alumno in listaAlumnosCurso)
            {
                Alumno.Asignatura = listaAsignaturas;
            }
            return listaAlumnosCurso;
        }
        private void CargarCursos()
        {
            Escuela.Cursos = new List<Curso>(){
                new Curso(){Nombre = "101",Jornada=TiposJornada.Mañana.ToString()},
                new Curso(){Nombre = "201",Jornada=TiposJornada.Mañana.ToString()},
                new Curso(){Nombre = "301",Jornada=TiposJornada.Mañana.ToString()},
                new Curso(){Nombre = "401",Jornada=TiposJornada.Mañana.ToString()},
                new Curso(){Nombre = "501",Jornada=TiposJornada.Mañana.ToString()},
                new Curso(){Nombre = "501",Jornada=TiposJornada.Tarde.ToString()},
                new Curso(){Nombre = "502",Jornada=TiposJornada.Tarde.ToString()}
            };
            Random rnd = new Random();
            foreach (var curso in Escuela.Cursos)
            {
                int cantidadRandom = rnd.Next(5, 20);
                curso.Alumnos = GenerarAlumnosAlAzar(cantidadRandom);
            }
        }
    }

A nu ma! mi solución es como 98% parecida a la del profe, ya no me siento tan babas xD puse mi código en los comentarios de la clase anterior.
Pd.
Se me hace más practico y creo que lo es para los recursos de la máquina, primero iterar la lista más grande inmediata dentro cursos, ya que para cada alumno hay una lista más pequeña de asignaturas, por lo contrario el código del profe itera pequeños grupos de asignaturas y sale por cada alumno y regresa. Creo que es más vuelta.
También en la calificación tengo un vago recuerdo de notación asintótica y costos de máquina es menos costosa la suma que la multiplicación, entonces yo saqué la parte entera y la parte decimal por separado y al final las sumé.
Lo del nombre aleatorio sólo lo dí en base al # de iteración de las 5 evaluaciones, osea no había mucho valor agregado ahí a mi punto de vista.

lo mas complicado fue la asignacion de las notas de las evaluaciones de las asignaturas del curso de cada estudiante

Dejo mi código:

Lo que mas me costo fue meter el nombre en cada evaluacion. En total me tomo poco mas de 2 hrs el reto y no se que tan efectivo es, Pero sin duda resuelve el reto.

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


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

                foreach (var al in c.Alumnos)
                {
                    c.Evaluaciones=CargarEvaluaciones(al.Nombre);
                }
               
            }
        }

         private List<Evaluaciones> CargarEvaluaciones(string alumnado)
        {
                string[] Nombre ={"Evaluacion de"};
                string[] Materia = {"Matematicas","Educacion fisica","Castellano","Naturales"};
                string[] Nivel = {"Inicial","Intermedio", "Avanzado", "Profecional","Experto"};
                Random rnd = new Random();
                
                var listaEvaluaciones =     from n1 in Nombre
                                            from m2 in Materia
                                            from n3 in Nivel
                                            select new Evaluaciones{Nombre=$"{n1} {m2} {n3}", Alumno=alumnado, Nota =(float)(5 * rnd.NextDouble()),};

            
            return listaEvaluaciones.OrderBy((al)=>al.UniqueId).Take(5).ToList();
        }```

    private void CargarEvaluaciones()
{
    foreach (var cur in Escuela.Cursos)
    {

        foreach (var asig in cur.Asignaturas)
        {
            Console.WriteLine("Curso " + cur.Nombre + "  " + asig.Nombre);
            for (int i = 1; i < 6; i++)
            {
                Console.WriteLine("           " + i.ToString() + " Parcial");

                foreach (var alu in cur.Alumnos)
                {
                    Random nota = new Random();
                    float cantRamdom = nota.Next(0, 5) + (float)nota.NextDouble();
                    //Console.WriteLine(Math.Round(cantRamdom, 1));
                    Evaluaciones = new Evaluaciones()
                    {
                        Alumno = alu,
                        Asignatura = asig,
                        Nombre = "Parcial ",//+ i.ToString(),
                        Nota = cantRamdom
                    };
                    //Console.WriteLine($" " + Evaluaciones.Nombre + " Nota:" + nota.ToString());
                    Console.WriteLine($"                   "+ alu.Nombre + " Nota: " + Evaluaciones.Nota);
                }
            }
        }

    }
}  	

private void CargarEvaluaciones()
{
foreach (var curso in Escuela.Cursos){
foreach (var asignatura in curso.Asignaturas){
foreach (var alumno in curso.Alumnos){
for (int i = 0; i < 5; i++)
{
var evaluacion=new Evaluaciones();
evaluacion.Nombre=$“Parcial {i+1}”;
evaluacion.Alumno=alumno;
evaluacion.Asignatura=asignatura;
float nrd2 = new Random().Next(1,11);
nrd2/=10;
float nrd= new Random().Next(1,6);
nrd+=nrd2;
evaluacion.nota=nrd;
}
}
}
}
}

Tengo estos errores y no entiendo como solucionarlos HEEELP

2

Yo lo hice así, terminé conviertiendo el float en double porque no me imprimia como decimal, y como double tampoco xd, asi que terminé poniendole un .0 ;"v

private void CargarEvaluaciones()
        {

             foreach (var c in Escuela.Cursos)
             {
                 Printer.DibujarTitulo($"Evaluaciones Por Curso y Asignatura {c.Nombre}");
                foreach (var a in c.Asignaturas)
                {
                        List<Evaluacion> listaEvaluaciones = new List<Evaluacion>();

                        for (int i = 0; i < 5; i++)
                        {
                            double number = GenerarNumeroAleatorio();
                            Evaluacion eval = new Evaluacion{Nombre=$"Evaluación {a.Nombre} #{i}", Nota=number};
                            listaEvaluaciones.Add(eval);
                        }

                        a.Evaluaciones = listaEvaluaciones;
                        Console.WriteLine("===========================");
                        Console.WriteLine($"Evaluaciones de la Asignatura de {a.Nombre}");
                        foreach (var Evaluacion in a.Evaluaciones)
                        {
                            Console.WriteLine($"{Evaluacion.Nombre}");
                        }
                        };

                    foreach (var al in c.Alumnos)
                    {

                        double number = GenerarNumeroAleatorio();
                        al.Evaluacion = new Evaluacion{Nombre="Evaluación de Ingreso", Nota=number};
                        Console.WriteLine($"{al.Nombre} Realizo la {al.Evaluacion.Nombre} y Obtuvo una nota de {al.Evaluacion.Nota}.0");
                                                
                    }
                }
             }

tengo problemas con la variable aljumno al final… en los comentarios dicen que hay que crear un constructor, pero no se donde crearlo,
ya que no se si modifico el constructor de Evaluaciones
o
creo un constructor nuevo de alumnos

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();
            float cantRandom = (float)rnd.Next(0,50) / 10;
            return (float) Math.Round(cantRandom, 1);
        }

private float ObtenerNota(Random rnd) => (float)Math.Round((5.0 * rnd.NextDouble()), 1);

Este es mi aporte:

private void CargarEvaluaciones()
{
List<String> TipoEvaluaciones = new List<string> { “Evaluación: 1”, “Evaluación: 2”, “Evaluación: 3”, “Evaluación: 4”, “Evaluación: 5” };
List<Evaluacion> evaluaciones = new List<Evaluacion>();

        foreach (var curso in Escuela.Cursos)
        {
            foreach (var alumno in curso.Alumnos)
            {
                foreach (var asignatura in alumno.asignaturas)
                {
                    foreach (var evaluacion in TipoEvaluaciones)
                    {
                        Evaluacion eva = new Evaluacion();
                        eva.Nombre = curso.Nombre;
                        eva.Alumno = alumno.Nombre;
                        eva.Asignatura = asignatura.Nombre;
                        eva.Nota = GenerarNotaAlAzar();
                        eva.EvaluacionN = evaluacion;
                        evaluaciones.Add(eva);
                    }
                }
            }
        }

        foreach (var evaluacion in evaluaciones)
        {
            WriteLine("Curso: " + evaluacion.Nombre + ", Alumno: " + evaluacion.Alumno + ", Asignatura: " + evaluacion.Asignatura + ", " + evaluacion.EvaluacionN + ", Nota: " + evaluacion.Nota);
        }
    }

Y el método:

    private float GenerarNotaAlAzar()
    {
        float note = (float)(5 * (new Random()).NextDouble());
        return (float)Math.Round(note * 100f) / 100f;          
    }

Decir que retoqué la clase Evaluaciones dejandola así:

using System;

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

    public string Nombre { get; set; }

    public string Alumno { get; set; }

    public string Asignatura { get; set; }

    public string EvaluacionN { get; set; }

    public float Nota { get; set; }

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

}

¿Cómo hicieron para que no les diera error la linea

alumno.Evaluaciones.Add(ev);

?

Ya que al inicio la lista alumno.Evaluaciones está null.

Aca el codigo:

https://github.com/JosefinaArayaTapia/CSharp/tree/master/Etapa1

En mi caso cree un método para cargar los Test de cada materia:

private List<Test> LoadTests()
        {
            string[] typeTest = { "Initial", "Formative", "Partial", "Global", "Previous", "Final", "Extension" };
            string[] level = { "Basic", "Quiz", "Medium", "Advanced", "Professional" };

            var listTest = from m1 in typeTest
                           from l1 in level
                           select new Test { NameTest = $"{m1} {l1}" };

            return listTest.OrderBy((ui) => ui.UniqueId).Take(5).ToList();

        }       

Luego que cargará cada test por materia de cada curso y una vez que se hubieran cargado todos los alumnos del curso llamaba una función para recorrer todos los alumnos y según ello ir asignando los tests por cada materia:

 private void LoadScoreStudents()
        {
            foreach (var course in School.Courses)
            {
                foreach (var student in course.Students)
                {
                    student.CourseName = course.NameCourse;
                    student.Subjects = course.Subjects;
                    student.Test = new List<Test>();

                    foreach (var subject in student.Subjects)
                    {
                        foreach (var test in subject.Test)
                        {
                            student.Test.Add(new Test
                            {
                                NameTest = test.NameTest,
                                Score = randomScore(),
                                SubjectName = subject.NameSubject,
                                StudentName = student.NameStudent
                            });
                        }
                    }
                }
            }
        }

Y para el puntaje cree una función para asignar puntajes aleatorios:

 private float randomScore()
        {
            double score = (new Random().NextDouble() * new Random().Next(0, 5));
            return (float)(Math.Round(score, 2));
        }

Nota: Para los niveles tomé un poco de inspiración de https://platzi.com/comentario/2005228/

En mi caso elaboré una solución que tuvo 2 premisas, la aleatoriedad del nombre del examen y la coherencia de que esos exámenes debían estar en cada uno de los alumnos del mismo curso.
Por ello es una solución un poco más extensa, pero estoy muy conforme con la singularidad del camino que tomé.

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

private void GenerarEvaluacionesAlAzar(int cantidad, List<Alumno> alumnos, Asignatura asignatura)
{
    string[] tipoEvaluacion = { "Parcial", "Examen", "Coloquio", "Trabajo práctico" };
    string[] tema = { "Unidad", "Tema", "Capitulo" };
    string[] numero = { "I", "II", "III", "IV","V","VI" };
    var listaEvaluaciones = from te1 in tipoEvaluacion
                            from t1 in tema
                            from n1 in numero
                            select new Evaluaciones { Nombre = $"{te1} {t1} {n1}" };
    listaEvaluaciones= listaEvaluaciones.OrderBy((e1) => e1.Id).Take(cantidad).ToList();
    foreach (var evaluacion in listaEvaluaciones)
    {
        foreach (var alumno in alumnos)
        {
            evaluacion.Alumno = alumno;
            evaluacion.Asignatura = asignatura;
            evaluacion.Nota = (float)new Random().Next(0, 500) / 100;
            alumno.Evaluaciones.Add(evaluacion);
        }
    }
}

Le añadi el atributo List<Evaluacion> a curso y luego añadi estos metodos

        private void CargarEvaluaciones()
        {
            foreach (Curso curso in Escuela.Cursos)
            {
                curso.Evaluaciones = new List<Evaluacion>();
                foreach (var asignatura in curso.Asignaturas)
                {
                    List<Evaluacion> evaluacionesAgignatura = GenerarEvaluacionesAlAzar(5);
                    foreach (var estudiante in curso.Alumnos)
                    {
                        // Generar nota para evaluacion del estudiante
                        foreach (var evaluacion in evaluacionesAgignatura)
                        {
                            curso.Evaluaciones.Add(new Evaluacion(){Nombre = evaluacion.Nombre, Asignatura = asignatura, Alumno = estudiante, Nota = (float)ObtenerNotaAleatoria(0, 5)});
                        }
                    }
                }
            }
        }

        private List<Evaluacion> GenerarEvaluacionesAlAzar(int cantidad){
            string[] titulos = {"Curso", "Proyecto", "Taller"};
            string[] dificultad = {"Facil", "Intermedio", "Avanzado"};
            var listaEvaluaciones = from t in titulos from d in dificultad select new Evaluacion {Nombre = $"{t} {d}"};
            return listaEvaluaciones.OrderBy((c) => c.UniqueId).Take(cantidad).ToList();
        }

        private double ObtenerNotaAleatoria(double minimo, double maximo){
            Random random = new Random();
            return random.NextDouble() * (minimo - maximo) + minimo;
        }

Otra solución usando LInq

private void CargarEvaluacionesACurso(Curso curso)
        {
            var alumnos = curso.Alumnos;
            var asignaturas = curso.Asignaturas;
            var numeroEvaluaciones = new List<int> {1, 2, 3, 4, 5};

            var evaluaciones = from alumno in alumnos
                               from asignatura in asignaturas
                               from numero in numeroEvaluaciones
                               select new Evaluacion($"Evaluacion de {asignatura.Nombre} #{numero.ToString()}", alumno, asignatura, MathUtil.ramdonFloat((float) 5.0, 2));

            evaluaciones.ToList().ForEach(evaluacion => evaluacion.Alumno.Evaluaciones.Add(evaluacion));
        }

private void CargarEvaluaciones()
{
    Random rnd = new Random();
    foreach (Curso curso in Escuela.Cursos)
    {
        string[] nombres = { "Nota 1", "Nota 2", "Nota 3", "Nota 4", "Nota 5" };
        var listaE = from al in curso.Alumnos
                     from asig in curso.Asignaturas
                     from n in nombres
                     select new Evaluacion(nombre: n, alumnoId: al.UniqueId, asignaturaId: asig.UniqueId, nota: (rnd.NextDouble() * 5).ToString("0.0"));
        curso.RegistroDeEvaluaciones.AddRange(listaE);
    }
}```