No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Generación de datos aleatorios

28/32
Recursos

Si un método tiene más de 50 líneas significa que está mal diseñado, cada método debe tener una sola responsabilidad. Es por eso por lo que vamos a separar en distintos métodos la carga de datos de nuestro proyecto.

Aportes 45

Preguntas 6

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

los nombres para que no tengan que descargar el archivo

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

Tip 💡.
Hace tiempo tuve la oportunidad de asistir a unas clases de C# en donde nos enseñaron pequeños trucos de optimización de código. El tip es este:
Las listas son una clase que por dentro tienen implementadas interfaces, en este caso la clase List tiene implementada la interfaz IEnumerable. Es por ello que podemos devolver este tipo de dato en la función CargarAlumnos.
La cuestión es: ¿Por qué devolvemos un IEnumerable en vez de un List de alumnos? La respuesta sería: si NO es necesario hacer operaciones con la lista, como añadir nuevos elementos, borrar, etc. Lo ideal es trabajar con IEnumerable ya que este no tiene cargada toda una estructura de una clase, por lo cual se ahorra toda la carga de funciones que NO serán usados. Ahora, si necesitamos seguir haciendo operaciones con la lista deberiamos devolver un tipo de dato List.

Diagrama de clases del proyecto de la Escuela, solo lo realicé como lo entendí, y no le puse las funciones/métodos como para dejar al libre análisis y comentarios constructivos para mejora del mismo.

Para los que quieran cargar las asignaturas:

List<Asignatura> 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"}
                };
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" };
.```

No entiendo por que en este curso se saltaron una parte en donde el profesor incluyo en el código cosas, es cierto que si te vas a los archivos están los cambios pero… Para mi no es clara esta parte del curso y mas si estas aprendiendo los fundamentos.

PLATZI ES GENIAL.

Pero…
Equipo de platzi por favor prestar atención a este tipo de cosas.

En que parte se creo Alumno.cs, Asignatura.cs, Evaluaciones.cs que no los vi?.

Si un método tiene más de 50 líneas significa que está mal diseñado, cada método debe tener una sola responsabilidad.

Me cae demasiado bien Juan Carlos! muchas gracias por el curso

El producto cartesiano revela una relación de orden entre dos conjuntos, constituyéndose como un tercer conjunto.

El producto cartesiano de un conjunto A y de un conjunto B es el conjunto constituido por la totalidad de los pares ordenados que tienen un primer componente en A y un segundo componente en B.

Se puede optimizar el código mas evitando tener que hacer el foreach para cargar los alumnos si cuando creamos los cursos lo hacemos al mismo tiempo

List<Alumno> alumnos = new List<Alumno>(CargarAlumnos());

            Escuela.Cursos = new List<Curso>{
                new Curso()
                    {
                        Nombre = "101",
                        Jornada = TiposJornada.Tarde,
                        Alumnos = alumnos
                    },
                new Curso()
                    {
                        Nombre = "202",
                        Jornada = TiposJornada.Mañana,
                        Alumnos = alumnos
                    },
                new Curso()
                    {
                        Nombre = "301",
                        Jornada = TiposJornada.Noche,
                        Alumnos = alumnos
                    }
                };   ```
Si se quiere hacer la creación de alumnos cada vez que se crea el curso solo hay que hacerlo así.



        Escuela.Cursos = new List<Curso>{
            new Curso()
                {
                    Nombre = "101",
                    Jornada = TiposJornada.Tarde,
                    Alumnos = new List<Alumno>(CargarAlumnos())
                },
            new Curso()
                {
                    Nombre = "202",
                    Jornada = TiposJornada.Mañana,
                    Alumnos = new List<Alumno>(CargarAlumnos())
                },
            new Curso()
                {
                    Nombre = "301",
                    Jornada = TiposJornada.Noche,
                    Alumnos = new List<Alumno>(CargarAlumnos())
                }
            };   ```

Espero que les guste.

Saludos.

Cuando el profe dijo: “Nos vemos en un próximo…”

Amigos dejo mi solución

private void CargarEvaluaciones()
        {

            double number;
            Random rnd = new Random();
            foreach (var cur in Escuela.Curso)
            {
                foreach (var alu in cur.Alumnos)
                {
                    foreach (var asig in cur.Asignaturas)
                    {
                        for (int i = 0; i < 5; i++)
                        {
                            number = rnd.NextDouble();
                            number = Math.Round(number * 5, 1);
                            var Evaluaciones = new Evaluaciones
                            {
                                Asignatura = asig.Nombre,
                                Alumno = alu.Nombre,
                                Nota = number,
                                Trismestre = i + 1
                            };
                        }

                    }
                }

            }
        }```

Para generar aleatorios existen algo que es ramdom

<public static void generarAleaotorio() {
            Random rnd = new Random();
            int month = rnd.Next(1, 13);
            Console.WriteLine(month);
        }>

Alguna vez en un proyecto vi Linq sin saber que era, ahora ya lo sé, gracias!

Una clase y un método solo pueden tener una responsabilidad, eso es parte de los principios SOLID, el principio de responsabilidad única. Para cuando se termine el curso pueden darle una ojeada a esos principios SOLID.

Si alguien tiene problemas al intentar hacer debug con breakpoints, puede probar descargar esto https://dotnet.microsoft.com/en-us/download/dotnet/2.1/runtime?cid=getdotnetcore

Minuto 1:16, que risa jajajaja!!!

asignatura" no contiene una definición para “AddRange” ni un método de extensión accesible “AddRange” que acepte un primer argumento del tipo “asignatura” (¿falta alguna directiva using o una referencia de ensamblado?) [proyectod] alguien me ayuda con esto sinceramente no se que me esta faltando

“Si un método tiene más de 50 lineas, problablemente está mal diseñado” 😲

Minuto 6:30 a 7:00 XD

Excelente

Esto de asignar rapidamente la variable con unos cliks se puede hacer en vim ?

Una forma de crear una lista de alumnos podría ser:

List<Alumno> alumnos = new List<Alumno>();
for (int i = 0; i < 30; i++)
            {
                var rand = new Random();
                string nombreCompleto = $"{nombre1[rand.Next(nombre1.Length)]} {nombre2[rand.Next(nombre2.Length)]} {apellido1[rand.Next(apellido1.Length)]}.";
                alumnos.Add(new Alumno(nombreCompleto));
            }```

De esta forma tienes control de cuantos alumnos quieres generar, en este ejemplo 30... Bueno es otra forma de hacerlo.

Crear los metodos antes de definirlos es la leche.

En realidad no se agregaron 5 materias. Solo agrego 4 jaja

Excelente!

Sería genial un diagrama de clases para saber como está estructurada la aplicación, platzi no tiene un curso de UML?

Buenas clases

Ya se esta poniendo interesante :v

genial esto de linq, escuchaba que se usaba mucho y lo había visto pero no entendía porqué era útil

Explica bn pero habla rapidisimo

no se porque me salta este error con n1 y n2

omg

Excelente demostración de uso de LinQ

Excelente clase.

Si un método tiene más de 50 líneas significa que está mal diseñado, cada método debe tener una sola responsabilidad. Es por eso por lo que vamos a separar en distintos métodos la carga de datos de nuestro proyecto.

Wow, es un tip simple pero muy bueno el que usó para combinar los arrays, ésta es una de clases muy buenas.
En Linq existen dos tiempos de notaciones, la Query y la Extensión.
el profe usó Query, ya estuve buscando y no encuentro la forma de hacerlo con extensión, seguro si hay, pero quedará algo muy rebuscado.
La notación de extensión se caracteriza por concatenar el resultado de una sentencia detrás de la otra y así crear una sola. por ejemplo:

var result = MyList.Where(x=> …).Select(y => new{}…).ToList();

Si son como yo y sacaron sus nombres y apellidos de una lista y no quieren ponerle comillas y comas nombre por nombre pueden usar esta expresión regular en VS Code para que añada esto. Quedaría así en find:
^ ?(.+)$

Y así queda en replace "$1",

Listo, nos vemos en un próximo video.

Donald Freddy Trump 0:

public static string GenerateName(int len)
          { 
              Random r = new Random();
              string[] consonants = { "b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "l", "n", "p", "q", "r", "s", "sh", "zh", "t", "v", "w", "x" };
              string[] vowels = { "a", "e", "i", "o", "u", "ae", "y" };
              string Name = "";
              Name += consonants[r.Next(consonants.Length)].ToUpper();
              Name += vowels[r.Next(vowels.Length)];
              int b = 2; //b tells how many times a new letter has been added. It's 2 right now because the first two letters are already in the name.
              while (b < len)
              {
                  Name += consonants[r.Next(consonants.Length)];
                  b++;
                  Name += vowels[r.Next(vowels.Length)];
                  b++;
              }

              return Name;


          }

 private void cargarAlumnos()
        {
            string [] nombre1 = {GenerateName(8), GenerateName(8), GenerateName(8)};
            string [] apellido1 = {GenerateName(10), GenerateName(10), GenerateName(10)};
            string [] nombre2 = {"Draco", "Severus", "Albus"};

        }

Ese apellido “Maduro” no quedó bien ahí xD