Refactoring siembra de datos

EscuelaContext.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.EntityFrameworkCore;

namespace HolaMundoMVC.Models
{
    public class EscuelaContext : DbContext
    {
        public DbSet<Escuela> Escuelas { get; set; }

        public DbSet<Asignatura> Asignaturas { get; set; }
        public DbSet<Alumno> Alumnos { get; set; }

        public DbSet<Curso> Curso { get; set; }

        public DbSet<Evaluación> Evaluaciones { get; set; }

        public EscuelaContext(DbContextOptions<EscuelaContext> options) : base(options)
        {

        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            var escuela = new Escuela();
            escuela.Nombre = "Platzi School";
            escuela.AñoDeCreación = 2005;
            escuela.TipoEscuela = TiposEscuela.Secundaria;
            escuela.Dirección = "5ta Calle";
            escuela.Ciudad = "Tecpan Guatemala";
            escuela.Pais = "Guatemala";

            //Cargar Cursos de la Escuela
            var cursos = CargarCursos(escuela);

            //x cada curso cargar asignaturas
            var asignaturas = CargarAsignaturas(cursos);

            //x cada curso cargar alumnos
            var alumnos = CargarAlumnos(cursos);

            modelBuilder.Entity<Escuela>().HasData(escuela);
            modelBuilder.Entity<Curso>().HasData(cursos.ToArray());
            modelBuilder.Entity<Asignatura>().HasData(asignaturas.ToArray());
            modelBuilder.Entity<Alumno>().HasData(alumnos.ToArray());

            // var listaAsignaturas = new List<Asignatura>(){
            //                 new Asignatura{Nombre="Matemáticas"} ,
            //                 new Asignatura{Nombre="Educación Física"},
            //                 new Asignatura{Nombre="Castellano"},
            //                 new Asignatura{Nombre="Ciencias Naturales"},
            //                 new Asignatura{Nombre="Programacion"}
            //     };
            // modelBuilder.Entity<Asignatura>().HasData(listaAsignaturas);

            // modelBuilder.Entity<Alumno>().HasData(GenerarAlumnosAlAzar(5).ToArray());
        }

        private List<Alumno> CargarAlumnos(List<Curso> cursos)
        {
            var listaAlumnos = new List<Alumno>();

            Random rnd = new Random();
            foreach (var curso in cursos)
            {
                int cantRandom = rnd.Next(5, 20);
                var tmplist = GenerarAlumnosAlAzar(curso, cantRandom);
                listaAlumnos.AddRange(tmplist);
            }
            return listaAlumnos;
        }

        private static List<Asignatura> CargarAsignaturas(List<Curso> cursos)
        {
            var listaCompleta = new List<Asignatura> ();
            foreach (var curso in cursos)
            {
                var tmpList = new List<Asignatura> {
                            new Asignatura{
                                CursoId = curso.Id,
                                Nombre="Matemáticas"} ,
                            new Asignatura{ CursoId = curso.Id, Nombre="Educación Física"},
                            new Asignatura{ CursoId = curso.Id, Nombre="Castellano"},
                            new Asignatura{ CursoId = curso.Id, Nombre="Ciencias Naturales"},
                            new Asignatura{ CursoId = curso.Id, Nombre="Programación"}

                };
                listaCompleta.AddRange(tmpList);
                //curso.Asignaturas = tmpList;
            }

            return listaCompleta;
        }

        private static List<Curso> CargarCursos(Escuela escuela)
        {
            return new List<Curso>(){
                        new Curso{
                            EscuelaId = escuela.Id,
                            Nombre = "101",
                            Jornada = TiposJornada.Mañana },
                        new Curso{EscuelaId = escuela.Id, Nombre = "201", Jornada = TiposJornada.Mañana},
                        new Curso{EscuelaId = escuela.Id, Nombre = "301", Jornada = TiposJornada.Mañana},
                        new Curso{EscuelaId = escuela.Id, Nombre = "401", Jornada = TiposJornada.Tarde},
                        new Curso{EscuelaId = escuela.Id, Nombre = "501", Jornada = TiposJornada.Tarde},
            };
        }

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

            var listaAlumnos = from n1 in nombre1
                               from n2 in nombre2
                               from a1 in apellido1
                               select new Alumno { CursoId = curso.Id,
                                Nombre = $"{n1} {n2} {a1}" };

            return listaAlumnos.OrderBy((al) => al.Id).Take(cantidad).ToList();
        }
    }
}

Respuesta al método para cargar los exámenes.

private List<Evaluación> CargarEvaluaciones(List<Curso> cursos, List<Asignatura> asignaturas, List<Alumno> alumnos, int numeroEvaluaciones = 5)
{
    Random rnd = new Random();
    var listaEv = new List<Evaluación>();
    foreach (var curso in cursos)
    {
        foreach (var asignatura in asignaturas)
        {
            foreach (var alumno in alumnos)
            {
                for (int i = 0; i < numeroEvaluaciones; i++)
                {
                    int cantRandom = rnd.Next(0, 500);
                    var tmp = new List<Evaluación> {
                        new Evaluación { 
                            Id = Guid.NewGuid().ToString(),
                            Nombre = "Evaluación de " + asignatura.Nombre + " # " + (i + 1),
                            AlumnoId = alumno.Id,
                            Alumno = alumno,
                            AsignaturaId = asignatura.Id,
                            Asignatura = asignatura,
                            Nota = (float)cantRandom/100
                        }
                    };
                    listaEv.AddRange(tmp);
                }
            }
        }
    }

    return listaEv;
}

El profesor debería moverse mas lentamente entre las distintas pantallas y dejar de pegar código no lo tenemos disponible en la sesión de archivos, porque se hace muy difícil poder seguirlo.

Realmente tuve varios inconvenientes y por supuesto que la opción que puse esta para mejora sim embargo logre hacer que funcionara la carga de evaluaciones

using System;
using System.Linq;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;

namespace project.Models
{
    public class EscuelaContext: DbContext
    {
        // Es la que nos va a manejar todo el contexto con la base de datos
        public DbSet<Escuela> Escuelas { get; set; }
        public DbSet<Asignatura> Asignaturas { get; set; }
        public DbSet<Alumno> Alumnos { get; set; }
        public DbSet<Curso> Cursos { get; set; }
        public DbSet<Evaluación> Evaluaciones { get; set; }

        // constructor que resive un contexto inllectado
        public EscuelaContext(DbContextOptions<EscuelaContext> options ) : base(options)
        {
            
        }


    protected override void OnModelCreating(ModelBuilder miModelBilder)
    {
      base.OnModelCreating(miModelBilder);

      var escuela = new Escuela()
      {
        Nombre = "Escuela Vogager",
        AñoDeCreación = 2020
      };
      miModelBilder.Entity<Escuela>().HasData(escuela);
      var cursos = CargarCursos(escuela);
      miModelBilder.Entity<Curso>().HasData(cursos);
      var asignaturas = CargarAsignaturas(cursos);
      miModelBilder.Entity<Asignatura>().HasData(asignaturas.ToArray());
      var alumnos = CargarAlumnos(cursos);
      miModelBilder.Entity<Alumno>().HasData(alumnos.ToArray());
      var evaluaciones = CargarEvaluaciones(cursos,asignaturas,alumnos);
      miModelBilder.Entity<Evaluación>().HasData(evaluaciones.ToArray());

      //por cada Alumno cargar 5 Evaluaciones

    }

    // private static IEnumerable<List<Evaluación>> CargarEvaluaciones(List<Curso> cursos,List<Asignatura> asignaturas,List<Alumno> alumnos)
    private static IEnumerable<Evaluación> CargarEvaluaciones(List<Curso> cursos,List<Asignatura> asignaturas,List<Alumno> alumnos)
    {
        var ListEval = new List<Evaluación>();
        Random rdm = new Random();
        foreach (var curso in cursos)
        {
            foreach (var alumno in alumnos)
            {
                foreach (var asign in asignaturas)
                {
                    var tmpEval = new List<Evaluación>();
                    for (int i = 0; i < 5; i++)
                    {
                        float nota = (float)((rdm.NextDouble() * 10)/2.0);
                        tmpEval.Add(
                            new Evaluación{
                                Nombre = $"{asign.Nombre}-{alumno.Nombre}",
                                AlumnoId = alumno.Id,
                                AsignaturaId = asign.Id,
                                Nota = nota,
                            }
                        );
                    }
                    ListEval.AddRange(tmpEval);
                }
            }
        }
        
        Random rdm2 = new Random();
        var count = new Object[5];

        var ListEval2 = from cu in cursos
                        from al in alumnos
                        from asig in asignaturas
                        from obj in count.ToList()
                        // select new List<Evaluación> {
                        select new Evaluación {
                            Nombre = $"{asig.Nombre}-{al.Nombre}",
                                            AlumnoId = al.Id,
                                            AsignaturaId = asig.Id,
                                            Nota = (float)((rdm.NextDouble() * 10)/2.0),
                            // new Evaluación {Nombre = $"{asig.Nombre}-{al.Nombre}",
                            //                 AlumnoId = al.Id,
                            //                 AsignaturaId = asig.Id,
                            //                 Nota = (float)((rdm.NextDouble() * 10)/2.0),},

                            // new Evaluación {Nombre = $"{asig.Nombre}-{al.Nombre}",AlumnoId = al.Id,AsignaturaId = asig.Id,Nota = (float)((rdm.NextDouble() * 10)/2.0),},
                            // new Evaluación {Nombre = $"{asig.Nombre}-{al.Nombre}",AlumnoId = al.Id,AsignaturaId = asig.Id,Nota = (float)((rdm.NextDouble() * 10)/2.0),},
                            // new Evaluación {Nombre = $"{asig.Nombre}-{al.Nombre}",AlumnoId = al.Id,AsignaturaId = asig.Id,Nota = (float)((rdm.NextDouble() * 10)/2.0),},
                            // new Evaluación {Nombre = $"{asig.Nombre}-{al.Nombre}",AlumnoId = al.Id,AsignaturaId = asig.Id,Nota = (float)((rdm.NextDouble() * 10)/2.0),},
                        };

        return ListEval2;
    }

    private List<Alumno> CargarAlumnos(List<Curso> cursos)
    {
        //por cada curso cargar alumno
        var listAlum = new List<Alumno>();
        Random rdn = new Random();
        foreach (var curso in cursos)
        {
            int cant = rdn.Next(15,20);
            var tmpAlumList = GenerarAlumnosAlAzar(curso, cant);
            listAlum.AddRange(tmpAlumList);
            // curso.Alumnos = tmpAlumList;
            // curso.Alumnos.AddRange(tmpAlumList);
        }
        return listAlum;
    }

    private static List<Asignatura> CargarAsignaturas(List<Curso> cursos)
    {
      //por cada curso cargar asignatura
      var tempList = new List<Asignatura>();
      foreach (var curso in cursos)
      {
          var asig = new List<Asignatura>{
                new Asignatura() { Nombre = "Desarrollo de Aplicaciones con ASP.NET",
                                   CursoId = curso.Id },
                new Asignatura() { Nombre = "Carrera de JavaScript", CursoId = curso.Id },
                new Asignatura() { Nombre = "Seguridad Informática", CursoId = curso.Id },
                new Asignatura() { Nombre = "Bases de Datos", CursoId = curso.Id },
                new Asignatura() { Nombre = "Inteligencia Artificial y Machine Learning", CursoId = curso.Id },
                new Asignatura() { Nombre = "Escuela de Data Science", CursoId = curso.Id },
                new Asignatura() { Nombre = "Ingles", CursoId = curso.Id },
          };
          tempList.AddRange(asig);
        //   curso.Asignaturas = asig;
        //   curso.Asignaturas.AddRange(asig);
      }
      return tempList;
    }

    private static List<Curso> CargarCursos(Escuela escuela)
    {

        //Cargar cursos de la escuela
        var cursos = new List<Curso>(){
                    new Curso{Nombre = "101", 
                              Jornada = TiposJornada.Mañana, 
                              EscuelaId = escuela.Id},
                    new Curso{Nombre = "201", Jornada = TiposJornada.Mañana, EscuelaId = escuela.Id},
                    new Curso{Nombre = "301", Jornada = TiposJornada.Mañana, EscuelaId = escuela.Id},
                    new Curso{Nombre = "401", Jornada = TiposJornada.Mañana, EscuelaId = escuela.Id},
                    new Curso{Nombre = "501", Jornada = TiposJornada.Mañana, EscuelaId = escuela.Id}
                };
        // escuela.Cursos = cursos;

        return cursos;
    }

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

            var listaAlumnos = from n1 in nombre1
                              from a1 in apellido1
                              from a2 in apellido2
                              select new Alumno{ 
                                    Nombre=$"{n1} {a1} {a2}" ,
                                    CursoId = classroom.Id
                                  };

            return listaAlumnos.OrderBy( (Al)=> Al.Id ).Take(cantidad).ToList();
        }
    }
}

No es bueno colocar tildes en los nombres de las clases, la clase “Evaluación” tiene tilde.

Me pueden ayudar me arrojo este error:
InvalidOperationException: The seed entity for entity type ‘Alumno’ cannot be added because there was no value provided for the required property ‘Id’.

es un trabajazo esto de sembrar datos, pero sino queda de otra para probar adelante.

Mi método para cargar las evaluaciones:

Respuesta al reto Método para carga de Exámenes

        private static List<Test> LoadingTest(List<Course> courses, List<Student> students, List<Subject> subjects, int testByCourses = 5)
        {
            var test = new List<Test>();
            Random rnd = new Random();
            foreach (var course in courses)
            {
                for(var i = 0;i<testByCourses;i++)
                {
                     var listTest = (from st in students.Where(s=>s.CourseId == course.Id)
                                from su in subjects.Where(s=>s.CourseId == course.Id)
                                where su.CourseId == st.CourseId
                                select new Test
                                {
                                    Name = $"Examen {i+1} de {su.Name}",
                                    StudentId = st.Id,
                                    SubjectId = su.Id,
                                    Result = MathF.Round((float)rnd.NextDouble() * 20, 2)
                                }).ToList();

                    test.AddRange(listTest);
                }

            }
            return test;
        }

Con Linq:

private List<Evaluación> CargarEvaluacionesLinq(List<Curso> cursos, List<Asignatura> asignaturas, List<Alumno> alumnos, int numeroEvaluaciones = 5)
        {
            Random random = new Random();
            var listaEvaluaciones = new List<Evaluación>();
            foreach (Curso curso in cursos)
            {                
                for (int i = 0; i < numeroEvaluaciones; i++)
                {
                    var evaluacionesPorCursoAlumno = from alum in alumnos
                                                     from asig in asignaturas
                                                     where alum.CursoId == curso.UniqueId && asig.CursoId == curso.UniqueId
                                                     select new Evaluación()
                                                     {
                                                         UniqueId = Guid.NewGuid().ToString(),
                                                         Nombre = "Evaluación N° " + (i + 1),
                                                         AlumnoId = alum.UniqueId,
                                                         AsignaturaId = asig.UniqueId,
                                                         Nota = (float)(random.Next(-1, 51) * 1.0f / 10.0f)
                                                     };
                    listaEvaluaciones.AddRange(evaluacionesPorCursoAlumno);
                }                
            }
            return listaEvaluaciones;
        }

Con For:

private List<Evaluación> CargarEvaluacionesFor(List<Curso> cursos, List<Asignatura> asignaturas, List<Alumno> alumnos, int numeroEvaluaciones = 5)
        {
            Random random = new Random();
            var listaEvaluaciones = new List<Evaluación>();
            foreach (Curso curso in cursos)
            {
                foreach (Asignatura asignatura in asignaturas)
                {
                    if (curso.UniqueId == asignatura.CursoId) 
                    {
                        foreach (Alumno alumno in alumnos)
                        {
                            if (curso.UniqueId == alumno.CursoId) 
                            {
                                var evaluacionesPorCursoAlumno = new List<Evaluación>();
                                for (int i = 0; i < numeroEvaluaciones; i++)
                                {
                                    float nota = (float)(random.Next(-1, 51) * 1.0f / 10.0f);
                                    var evaluacionPorAlumno = new Evaluación
                                    {
                                        UniqueId = Guid.NewGuid().ToString(),
                                        Nombre = "Evaluación N° " + (i + 1),
                                        AlumnoId = alumno.UniqueId,
                                        AsignaturaId = asignatura.UniqueId,
                                        Nota = nota
                                    };
                                    evaluacionesPorCursoAlumno.Add(evaluacionPorAlumno);
                                }
                                listaEvaluaciones.AddRange(evaluacionesPorCursoAlumno);
                            }
                        }
                    }                    
                }
            }
            return listaEvaluaciones;
        }

P.D. Sigo usando UniqueId como clave principal.

Respuesta al desafio:

La función:

private static List<Evaluacion> CargarEvaluaciones(List<Alumno> alumnos, List<Asignatura> asignaturas) {
            var evaluaciones = new List<Evaluacion>();
            foreach (var alumno in alumnos)
            {
                foreach (var asignatura in asignaturas)    
                {
                    var evaluacion = new Evaluacion();
                    Random rnd = new Random();
                    evaluacion.Id = Guid.NewGuid().ToString();
                    evaluacion.Nombre = "Primer Parcial";
                    evaluacion.AlumnoId = alumno.Id;
                    evaluacion.AsignaturaId = asignatura.Id;
                    evaluacion.Nota = rnd.Next(1,10);
                    evaluaciones.Add(evaluacion);
                    
                }
            }
            return evaluaciones;
}```

Tuve un bug que es el mismo que le paso a Juan, que es cuando le asignas tambien el objeto alumno y asignatura. Se lo sacas y funciona por el tema de la convención.

¿Como puedes sembrar los datos de tipo Curso en CargarAsignaturas?

En este momento el profesor crea una variable temporal para almacenar la lista, esto podemos ahorrarlo si a listaCompleta le añadimos el Campo asignaturas de Curso que ya contiene la lista que estamos "Extrayendo" asi podemos ahorrarnos una variable que quedara ahi dormida.

27 Julio 2023

Importante Eliminar el capo de Direccion de Curso.Cs

using System;
using System.Linq;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using Microsoft.IdentityModel.Tokens;

namespace Escuela_asp.Models
{
    public class EscuelaContext: DbContext
    {
        public DbSet<Escuela> Escuelas { get; set; }
        public DbSet<Asignatura> Asignaturas { get; set; }
        public DbSet<Alumno> Alumnos { get; set; }
        public DbSet<Curso> Cursos { get; set; }
        public DbSet<Evaluación> Evaluaciones { get; set; }

        public EscuelaContext (DbContextOptions<EscuelaContext> options): base(options)
        {

        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);


            var escuela = new Escuela();
            escuela.AñoDeCreación = 1972;
            escuela.Id = Guid.NewGuid().ToString();
            escuela.Nombre = "ESTI No. 3";
            escuela.Ciudad = "Xalapa";
            escuela.Pais = "México";
            escuela.TipoEscuela = TiposEscuela.Secundaria;
            escuela.Dirección = "Avila Camacho 502";

            //Cargar Cursos de la escuela

            var cursos = CargarCursos(escuela);

            //x cada curso cargar asignaturas
            var asignaturas = CargarAsignaturas(cursos);

            //x cada curso cargar alumnos
            var alumnos = CargarAlumnos(cursos);

            //x cargar evaluaciones - tarea

            var evaluaciones = CargarEvaluaciones(cursos, asignaturas, alumnos);

            modelBuilder.Entity<Escuela>().HasData(escuela);
            modelBuilder.Entity<Curso>().HasData(cursos.ToArray());
            modelBuilder.Entity<Asignatura>().HasData(asignaturas.ToArray());
            modelBuilder.Entity<Alumno>().HasData(alumnos.ToArray());
            modelBuilder.Entity<Evaluación>().HasData(evaluaciones.ToArray());
        }

        private static List<Evaluación> CargarEvaluaciones(List<Curso> cursos, List<Asignatura> asignaturas, List<Alumno> alumnos)
        {
            List<Evaluación> listaEvaluaciones = new List<Evaluación>();
            foreach (var curso in cursos)
            {
                foreach (var asignatura in asignaturas)
                {
                    foreach (var alumno in alumnos)
                    {
                        Random rnd = new Random();
                        int eval_rnd = rnd.Next(0, 100);
                        List<Evaluación> tmplist = new List<Evaluación>
                        {
                            new Evaluación{Nombre = "Evaluacion", AlumnoId = alumno.Id, AsignaturaId = asignatura.Id, Nota = (float) eval_rnd/10 }
                        };
                        listaEvaluaciones.AddRange(tmplist);

                    }
                }
            }
            return listaEvaluaciones;
        }

        private List<Alumno> CargarAlumnos(List<Curso> cursos)
        {
            var listaAlumnos = new List<Alumno>();

            Random rnd = new Random();
            foreach (var curso in cursos)
            {
                int cantRandom = rnd.Next(5, 20);
                var tmplist = GenerarAlumnosAlAzar(curso, cantRandom);
                listaAlumnos.AddRange(tmplist);
            }

            return listaAlumnos;
        }

        private static List<Asignatura> CargarAsignaturas(List<Curso> cursos)
        {
            var listaCompleta = new List<Asignatura>();
            foreach (var curso in cursos)
            {
                List<Asignatura> tmplist = new List<Asignatura> //warning var tmplist
                {
                    new Asignatura{ Id = Guid.NewGuid().ToString(), CursoId = curso.Id, Nombre= "Matemáticas"},
                    new Asignatura{ Id = Guid.NewGuid().ToString(), CursoId = curso.Id, Nombre= "Educacion Fisica"},
                    new Asignatura{ Id = Guid.NewGuid().ToString(), CursoId = curso.Id, Nombre= "Castellano"},
                    new Asignatura{ Id = Guid.NewGuid().ToString(), CursoId = curso.Id, Nombre= "Ciencias naturales"},
                    new Asignatura{ Id = Guid.NewGuid().ToString(), CursoId = curso.Id, Nombre= "Programacion"},
                };
                listaCompleta.AddRange(tmplist);
                //curso.Asignaturas = tmplist;
            }
            return listaCompleta;
        }

        private static List<Curso> CargarCursos(Escuela escuela)
        {
            return new List<Curso>()
            {
                new Curso(){
                    Id = Guid.NewGuid().ToString(), EscuelaId = escuela.Id, Nombre = "101", Jornada = TiposJornada.Mañana },
                new Curso(){
                    Id = Guid.NewGuid().ToString(), EscuelaId = escuela.Id, Nombre = "201", Jornada = TiposJornada.Mañana },
                new Curso(){
                    Id = Guid.NewGuid().ToString(), EscuelaId = escuela.Id, Nombre = "301", Jornada = TiposJornada.Mañana },
                new Curso(){
                    Id = Guid.NewGuid().ToString(), EscuelaId = escuela.Id, Nombre = "401", Jornada = TiposJornada.Mañana },
                new Curso(){
                    Id = Guid.NewGuid().ToString(), EscuelaId = escuela.Id, Nombre = "501", Jornada = TiposJornada.Mañana }
            };
        }

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

            var listaAlumnos = from n1 in nombre1
                               from n2 in nombre2
                               from a1 in apellido1
                               select new Alumno { CursoId = curso.Id,  Nombre = $"{n1} {n2} {a1}", Id = Guid.NewGuid().ToString() };

            return listaAlumnos.OrderBy((al) => al.Id).Take(cantidad).ToList();
        }
    }
}

Todo lo que ocurre desde el minuto 8:00 es muy confuso…

EscuelaContext.cs

// Cargar Cursos de la Escuela
    var cursos = CargarCursos(escuela);
// x cada Curso cargar Asignaturas
    var listaAsignaturas = CargarAsignaturas(cursos);
// x cada Curso cargar Alumnos
    var listaAlumnos = CargarAlumnos(cursos);
// Tarea: cargar Evaluaciones  
private static List<Curso> CargarCursos(Escuela escuela)
{
    var listaCursos = new List<Curso>() {
        new Curso {
        Nombre = "101",
        Id = Guid.NewGuid ().ToString (),
        EscuelaId = escuela.Id,
        Jornada = TiposJornada.Mañana
        },
        new Curso {
        Id = Guid.NewGuid ().ToString (),
        Nombre = "201",
        EscuelaId = escuela.Id,
        Jornada = TiposJornada.Mañana
        },
        new Curso {
        Id = Guid.NewGuid ().ToString (),
        EscuelaId = escuela.Id,
        Nombre = "301",
        Jornada = TiposJornada.Mañana
        },
        new Curso {
        Id = Guid.NewGuid ().ToString (),
        EscuelaId = escuela.Id,
        Nombre = "401",
        Jornada = TiposJornada.Tarde
        },
        new Curso {
        Id = Guid.NewGuid ().ToString (),
        EscuelaId = escuela.Id,
        Nombre = "501",
        Jornada = TiposJornada.Noche
        }
    };
    return listaCursos;
}
private static List<Asignatura> CargarAsignaturas(List<Curso> cursos)
{
    var listaCompleta = new List<Asignatura>(); 
    foreach (var curso in cursos)
    {
        var asignaturas = new List<Asignatura>() {
            new Asignatura {
            Id = Guid.NewGuid ().ToString (),
            CursoId = curso.Id,
            Nombre = "Matemáticas",
            },
            new Asignatura {
            Id = Guid.NewGuid ().ToString (),
            CursoId = curso.Id,
            Nombre = "Educación Física",
            },
            new Asignatura {
            Id = Guid.NewGuid ().ToString (),
            CursoId = curso.Id,
            Nombre = "Castellano",
            },
            new Asignatura {
            Id = Guid.NewGuid ().ToString (),
            CursoId = curso.Id,
            Nombre = "Ciencias Naturales",
            },
            new Asignatura {
            Id = Guid.NewGuid ().ToString (),
            CursoId = curso.Id,
            Nombre = "Programación",
            }
        };
        listaCompleta.AddRange(asignaturas);
    }
    return listaCompleta;
}
private List<Alumno> CargarAlumnos(List<Curso> cursos)
{
    var listaCompleta = new List<Alumno>();
    var rnd = new Random();
    foreach (var curso in cursos)
    {
        int cantRandom = rnd.Next(5, 20);
        var listaAlumnos = this.GenerarAlumnosAlAzar(curso, cantRandom);
        listaCompleta.AddRange(listaAlumnos);
    }
    return listaCompleta;
}

Tarea

private List<Evaluación> CargarEvaluaciones(
            IEnumerable<Asignatura> asignaturas,
            IEnumerable<Alumno> alumnos)
        {
            var listaEvaluacion = new List<Evaluación>();

            Random rnd = new Random();

            foreach (var alumno in alumnos)
            {
                foreach (var asignatura in asignaturas)
                {
                    var lstEvaltmp = new List<Evaluación>();

                    for (int i = 0; i < 5; i++)
                    {
                        var evaluacion = new Evaluación
                        {
                            AlumnoId = alumno.Id,
                            AsignaturaId = asignatura.Id,
                            Nombre = $"{asignatura.Nombre} Ev#{i + 1}",
                            Nota = MathF.Round(
                                (float)(10 * rnd.NextDouble()), 2),
                        };

                        lstEvaltmp.Add(evaluacion);
                    }

                    listaEvaluacion.AddRange(lstEvaltmp);
                }
            }

            return listaEvaluacion;
        }

Interesante

🤓

Interesante este capitulo, para entender mas a fondo Entity

Excelente esta distribución del código para hacer la siembra de los datos

private static List<Evaluación> CargarEvaluaciones(List<Curso> cursos)
        {
            var ListaEvaluaciones = new List<Evaluación>();
            var rnd = new Random();
            foreach (var curso in cursos)
            {
                foreach (var asignatura in curso.Asignaturas)
                {   
                    foreach (var alumno in curso.Alumnos)
                    {
                        for (int i = 0; i < 5; i++)
                        {
                            var ev = new Evaluación(){
                                Asignatura = asignatura,
                                Nombre = $"{asignatura.Nombre} Evaluación#{i + 1}",
                                Nota = MathF.Round(5*(float)rnd.NextDouble(),2),
                                Alumno = alumno,
                                AlumnoId = alumno.Id,
                                AsignaturaId = asignatura.Id
                            };
                            alumno.Evaluaciones.Add(ev);
                        }
                        asignatura.Evaluaciones.AddRange(alumno.Evaluaciones);
                    }
                    ListaEvaluaciones.AddRange(asignatura.Evaluaciones);
                }
            }

            return ListaEvaluaciones;
        }

exclente clase

Así sería.

        private List<Evaluación> CargarEvaluaciones(List<Asignatura> asignaturas, List<Curso> cursos, List<Alumno> alumnosList) 
        {
            var listaCompleta = new List<Evaluación>();
            Random rnd = new Random();
            foreach (var asig in asignaturas)
            {
                foreach (var curso in cursos?.Where(a=>a.Id == asig.CursoId))
                {
                    foreach (var alu in alumnosList.Where(a=>a.CursoId == curso.Id).ToList()) 
                    {
                            listaCompleta.Add
                            (
                                new Evaluación()
                                {
                                    Id = Guid.NewGuid().ToString(),
                                    AsignaturaId = asig?.Id,
                                    AlumnoId = alu.Id,
                                    Nombre = $"Evalucación de {alu?.Nombre}",
                                    Nota = rnd.Next(0, 10)
                                }
                            );
                    }
                }                
            }
            return listaCompleta;
        }