Refactoring siembra de datos

Luis Abdel Rangel Castro

student•

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

John Salcedo

student•

a este archivo le falta la generacion de Id en Asignatura, Alumno, es mejor que utilicen directamente el del curso, o lo comparen.

José Ángel Soriano Soriano

student•

la solucion es : en la clase Curso.cs, agregar public string Id { get; set; } y quitar la propiedad direccion

en la clase Alumno.cs, agregar public string Id {get; set; }

con eso se soluciona

Oscar Eduardo Palomino Cárdenas

student•

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

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

    return listaEv;
}

Adrian Baudo

student•

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.

Anderson Duarte Santos

student•

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

Danny Pineda

student•

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

KEVIN BRAYAN LUNA FIGUEROA

student•

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

Alberto González

student•

¡Hola! ¿Tienes el código para poder echarle un vistazo?

Edward Rodríguez

student•

Buenas, pudiste solucionar este error? Tengo el mismo problema.

Carlos Javier Bazan Huaman

student•

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

Johan Andrey Chala Sanchez

student•

Mi método para cargar las evaluaciones:

Pedro Roberto Capriles Morales

student•

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

Johan Bruce Chirito Guerra

student•

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.

Walter Lensinas

student•

Respuesta al desafio:

La función:

private static List&lt;Evaluacion&gt; CargarEvaluaciones(List&lt;Alumno&gt; alumnos, List&lt;Asignatura&gt; asignaturas) {
            var evaluaciones = new List&lt;Evaluacion&gt;();
            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 = &quot;Primer Parcial&quot;;
                    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.

Agustin Emilio Alcantara Corporan

student•

No lo he probado, pero luce excelente!

Mario Narvaez Tamayo

student•

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

Juan Carlos Ruiz Pacheco

teacher•

Explicate un poco mejor, porque no me queda clara tu inquietud.,

Leonardo Ernesto Solórzano Carrasquero

student•

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.

Cristian Faraht Alvear Macias

student•

Buenas noches, en mis prácticas estoy usando Visual Studio Community 2017, existe una diferencia con Visual Studio Code??

José Eduardo López Prieto

student•

En un principio, desde mi punto de vista, te ocupa menos recursos con respecto al uso de memoria RAM y el Visual Studio <Versión Que Quieras> tiene más opciones para poder realizar rapidamente el desarrollo ya que contiene toolbox, mientras que el Visual Studio Code se dirige a un uso menos "visual" y que hay que realizarlos "a mano", pero eso es mi punto de vista.

Cristhian Franco

student•

Las diferencias se miran en las heramientas, como atajos y autocompletado de la sintaxis, tambien en el rendimiento como menciono Jelopez, otra cosa a tomar en cuenta es que VS Code puede ser usado en linux, mientras que Visual Studio hasta la fecha no tiene una version para Linux.

Antonio Aguilar

student•

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

Jose Antonio Diaz Urbano

student•

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

Leonardo Valdivieso

student•

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

Miguel Ignacio Gonzalez Cuevas

student•

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

Oscar Jaramillo

student•

Interesante

Oscar Jaramillo

student•

🤓