A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Curso de ASP.NET Core

Curso de ASP.NET Core

Juan Carlos Ruiz

Juan Carlos Ruiz

Refactoring siembra de datos

23/35
Recursos

Aportes 22

Preguntas 5

Ordenar por:

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

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

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

Me pueden ayudar me arrojo este error:
InvalidOperationException: The seed entity for entity type 鈥楢lumno鈥 cannot be added because there was no value provided for the required property 鈥業d鈥.

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

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.

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.

No es bueno colocar tildes en los nombres de las clases, la clase 鈥淓valuaci贸n鈥 tiene tilde.

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

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.

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