A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Resoluci贸n del reto

31/32
Recursos

Aportes 87

Preguntas 2

Ordenar por:

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

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 鈥渕谩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铆?

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

En este video no sali贸 pero la clase 鈥淎lumno鈥 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>(){};
        } 
        
    }
}```

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

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鈥sta 煤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();
        
    }```

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;

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

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

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 鈥渇oreach鈥 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 鉁-

Resultado Reto:

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.

Incre铆ble curso, muy f谩cil de llevarlo, lo termine ennun par de d铆as.

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 鈥淣ota鈥 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!!!

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

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=$鈥淧arcial {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> { 鈥淓valuaci贸n: 1鈥, 鈥淓valuaci贸n: 2鈥, 鈥淓valuaci贸n: 3鈥, 鈥淓valuaci贸n: 4鈥, 鈥淓valuaci贸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.

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