Datos de prueba

Pienso que un problema de este curso… es que cambia muchas cosas ya creadas, me parece que al ser fundamentos y pensado para alguien primerizo no debería de lanzar tantas formas de hacer algo con el mismo resultado, solo sugerir la mejor forma de hacerlo. No sabes cual opción cachar y al final ninguna te acomoda xD.

Sin embargo, esta es la tercera vez que lo veo y recién entiendo cada una de las formas de hacer cada cosa y todos los cambios que hace super rápido… PARA HACER LO MISMO, PERO DE DIFERENTE FORMA. xD

Es bueno el curso, pero es mejorable.

Solo es una critica. Amor a todos.

Con respecto a la pregunta que hace el instructor, en mi caso, no ha sido del todo fácil; explica bastantes cosas y detalles rápido y, aunque soy programador, hay cosas bastante nuevas en cuanto al lenguaje y a la metodología del desarrollo.

Sin embargo, continúo porque vale la pena algo nuevo. ¿A alguien más le pasa esto?

Sinceramente el curso ha sido BUENISIMO 10/10

Como crítica, al iniciar el curso, creo que sería bueno indicar que los estudiantes primero tomen el curso de Prog Básica y el de Prog estructurada.

Ya que las cosas “básicas” de la programación las explicó muy rápido, cosa que a mí me vino de maravilla por lo que no soy tan Novato en la prog, pero para aquellos que es su primer lenguaje y no saben nada, les puede ser muy, muy difícil tanta información.

De un video de 15 minutos estoy 1 hora

Realmente ando siguiendo lentamente cada paso, por lo que estoy haciendo un simple copy paste, me tardo bastante en entender como se comunica cada archivo y en si mismo como es que funciona cada propiedad que le agregamos a la escuela.
Por ahí estaba pensando en cuanto termine, agregarle una especie de grado especial, tipo refuerzo y que lleve a alumnos automáticamente que tenga notas bajas. Pero eso mas adelante.

Modifique un poco el código. Cree un método para asignar alumnos a cada curso que llama a CrearAlumnos, y que toma un parámetro int que va a ser una variable random inicializada en el primer método que mencione.

Así solo se crea una cantidad moderada de alumnos por curso y no se crean los 391 objetos cada vez que se llama al método para crear alumnos.

Gran clase!!! Estoy aprendiendo cada vez más

        private List<Alumno> CrearAlumnos(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 { Nombre = $"{n1} {n2} {a1}" };
            return listaAlumnos.OrderBy((al) => al.UniqueId).Take(cantidad).ToList();
        }

        private void CargarCursos()
        {
            Escuela.Cursos = new List<Curso>(){
                new Curso {Nombre = "101", Jornada = TiposJornada.Mañana},
                new Curso {Nombre = "201", Jornada = TiposJornada.Mañana},
                new Curso {Nombre = "301", Jornada = TiposJornada.Mañana},
                new Curso {Nombre = "401", Jornada = TiposJornada.Tarde},
                new Curso {Nombre = "501", Jornada = TiposJornada.Tarde}
            };
            asignarAlumnos();
        }

        private void asignarAlumnos()
        {
            foreach (var curso in Escuela.Cursos)
            {
                var random = new Random().Next(5, 25);
                curso.Alumnos = CrearAlumnos(random);
                foreach (var al in curso.Alumnos)
                {
                    al.Curso = curso;
                }
            }

        }

Para que sirva la función AddRange de las listas es necesario inicializar la lista asi sea vacia con eso después de que recorremos con el for no nos sacará la excepción, a continuación les comparto parte de las líneas de código que me funcionaron para esto:

public Course() =>(this.UniqueId,this.ListStudents) =( Guid.NewGuid().ToString(),new List<Student>());

Se debe tener en cuenta que es necesario generar una sobre carga del constructor de la clase estudiante[student] para que no reciba ningún parametro de entrada para crear alumnos.

public class Student
    {
        public Guid ID { get; set; }
        public string Name { get; set; }

        public Student(){}
        public Student(string n) => (ID, Name) =(Guid.NewGuid(),n);  
    }```

Y en el for para adicionar la lista de estudiantes sólo es necesario añadir el método AddRange

Random rnd = new Random();

        foreach (var course in school.courses)
        {
            int len = rnd.Next(5,20);
            course.ListStudents.AddRange(initStudents(len));

}```

Este curso es máginifico a nivel de conocimiento y la forma en que se imparte!

La unica retroalimentación que puedo darle, es que hubiera sido mucho mejor si desde el principio hubieran estructurado todo en un diagrama UML, así los estudiantes sabríamos a donde estamos yendo y con que relaciones tenemos que contar, pienso que la diagramación UML es una parte fundamental de todo desarrollo!

la lista alumnos me aparece vacía

Gracias, muy buena clase, sólo veo un par de observaciones.
En el método carga CargarAlumnos, se quiere intenta tomar “Aleatoriamente” la cantidad enviada en
CargarAlumnos(int cantidad).
Tal cual está el ejemplo, funciona, pero porque en cada iteración de cursos donde se llama a CargarAlumnos, se crean cada vez los 391 alumnos, por eso hay Guids diferentes siempre, los cuales se ordenan nuevamente en cada ciclo y no se va a repetir en nuestro Take().
El problema es la misma solución, en un ejemplo practico no se debería de crear un conjunto de datos “Grande” cada vez, porque supongamos que es una llamada a un servicio o BD se va a repetir la consulta siempre, eso a parte de que va a consumir el recurso externo innecesariamente nos va a consumir memoria y tiempo de ejecución de más.
Por lo cual debería de estar separada la creación del conjunto de datos una sola vez y el take aleatorio manejarlo con aleatorios que tomen fragmentos de la única lista original para que realmente no se repitan.
Es decir el error original es que se está “asegurando” un set aleatorio en el Guid pero no en las combinaciones generadas.

Otra nota es que también no me permitía meter la lista de asignaturas a cada curso aquí:

CargarCursos();
CargarAsignaturas();
var listaAlumni = CargarAlumnos();
foreach (var curso in Escuela.CursosLista)
{
curso.Alumnos = listaAlumni.ToList();
}

Ya que me argumentaba no poder convertir un IEnumerable a List.
Entonces puedes hacer esa conversión con ToList():

curso.Alumnos = listaAlumni.ToList();

Cheers!

llegue hasta esta clase, quede super perdido , tengo bases de programación pero hay bastantes cosas nuevas , descansar un rato y retomar de a poco

En esta clase iba a todo gas. Parece que ya le urgía acabar el curso 🤭 Pero vamos 10/10

Siempre hay algo nuevo que aprender, he aprendido bastante hasta este punto, a pesar de usar C# desde hace varios años. 😄 haha

Como todos los lenguajes tienen su complejidad, pero estoy aprendiendo bien aunque un video de 15 minutos para mi se convierta en una hora estoy aprendiendo mucho y en especializarme en este lenguaje, profe Carlos Ruiz es excelente

Como nota tuve un problema al agregar listaAsignaturas a curso.Asignaturas en el métido CargarAsignaturas de la forma

var listaAsignaturas = [...codigo...];
Curso.Asignaturas.AddRange(listaAsignaturas)

Pero metí la lista sin problemas con:

var listaAsignaturas = [...codigo...];
curso.Asignaturas = listaAsignaturas

Buen curso pero en la explicación está mezclando temas en vez de ir despacio y dando definiciones entendibles de cada cosa, mezcla todo y no da una base clara para el estudiante para que aproveche todo el material que intenta impartir, sería bueno que se centren en una cosa conceptos y otro curso de practica de los conceptos que se adquiere eso ayudaría en el proceso total.

Yo siguiendo el paso a paso de la creación de la escuela para aplicarlo a un proyecto nuevo.

Vengo de otro lenguaje orientado a objetos y quería explorar el mundo C# pero en ocasiones se me hace un poco enredado y mas al reacomodar código, se borran cosas y se cambian por otras que es cierto queda mejor pero lo que estaba antes también es útil. Es mejor explicar una sola forma y dejarla todo el curso porque se enreda uno mas. Pero resalto que la lógica y el conocimiento del profesor es muy bueno.

Buenas comparto contenido del curso y breve documentacion del contenido

using System;
using System.IO.Pipes;
using System.Security.Cryptography;
using CoreEscuela.Entidades;
using System.Linq;
using System.Collections.Generic;

namespace CoreEscuela
{
    public class EscuelaEngine
    {
        public Escuela Escuela { get; set; }

        public EscuelaEngine()
        {
            Inicializar();
        }

        public void Inicializar()
        {
            Escuela = new Escuela("Escueña 12", 1990, TiposEscuela.Primaria, pais: "Colombia", ciudad: "medellin");

            CargarCursos();
            CargarAsignaturas();
            
            foreach(var curso in Escuela.Cursos)
            {
                curso.Alumnos.AddRange(CargarAlumnos(10));
            }
            
            
            CargarEvalucacion();
        }

        private void CargarEvalucacion()
        {
            
        }

        private void CargarAsignaturas()
        {
            foreach(var curso in Escuela.Cursos)
            {
                List<Asignatura> listaAsignatura = new List<Asignatura>()
                {
                    new Asignatura{Nombre = "Matematicas"},
                    new Asignatura{Nombre = "Etica"},
                    new Asignatura{Nombre = "Fisica"},
                    new Asignatura{Nombre = "Sociales"}
                };

                curso.Asignaturas =listaAsignatura;


            }
        }

        private IEnumerable<Alumno> CargarAlumnos(int cantidadAlumnos)
        {
            string[] Nombres = {"Felipe","Adrian","Sandra","Catalina","Juan David","Maria Alejandra"};
            string[] Apellido ={"Lopez","Martinez","Gonzalez","Ramirez","Munera","Arboleda"};

            var listaAlumnos = from nom1 in Nombres
                               from ape1 in Apellido
                               select new Alumno{Nombre = $"{nom1} {ape1}"};
            return listaAlumnos.OrderBy((x)=> x.AlumnoId).Take(cantidadAlumnos).ToList();

        }

        private void CargarCursos()
        {
            Escuela.Cursos = new List<Curso>(){
                new Curso(){Nombre = "Sexto", Jornada= TiposJornada.Manaña},
                new Curso(){Nombre = "Septimo", Jornada = TiposJornada.Manaña},
                new Curso(){Nombre = "Octavo" , Jornada = TiposJornada.Manaña},
                new Curso(){Nombre = "Noveno", Jornada = TiposJornada.Tarde},
                new Curso(){Nombre = "Decimo", Jornada = TiposJornada.Tarde},
                new Curso(){Nombre = "Once", Jornada = TiposJornada.Noche}
            };
            Random rnd = new Random();
            
            foreach (var cur in Escuela.Cursos)
            {
                int cantidad = rnd.Next(5,20);
                cur.Alumnos = CargarAlumnos(cantidad).ToList();
            }
        }
    }
}

using System;
using System.Runtime.Serialization.Json;
using CoreEscuela;
// See https://aka.ms/new-console-template for more information
using CoreEscuela.Entidades;


var engine = new EscuelaEngine();
Console.WriteLine("=======================================");
Imprimir(engine.Escuela);


static void Imprimir(Escuela escuela)
{
    Console.WriteLine("=======================");
    Console.WriteLine("Cursos de la Escuela 12");
    Console.WriteLine("=========================");
    
    if(escuela?.Cursos !=null)
    {
        foreach(var curso in escuela.Cursos)
        {
            Console.WriteLine($"Nombre: {curso.Nombre}, CursoId: {curso.CursoId}");
        }
    }
}

// Console.WriteLine("Hello, World!");
/* Agregando datos Escuela */
// Escuela es = new Escuela("Escuela Basicas",1995,TiposEscuela.Primaria,ciudad: "Medellin", pais: "Colombia");

/* Agregando cursos

 Curso cursos1 = new Curso();
 cursos1.Nombre="Pruebas";
 cursos1.Jornada =TiposJornada.Manaña;


 var curso2 = new Curso()
 {
    Nombre = "102",
     Jornada = TiposJornada.Tarde
 };

*/

/* agregando cursos utilizando arrays[]

 var arrayCursos = new Curso[3];

 arrayCursos[0] = new  Curso(){
     Nombre = "301",
     Jornada = TiposJornada.Noche
 } ;

 var cursos2 = new Curso(){
     Nombre="302",
     Jornada = TiposJornada.Noche
 };
 arrayCursos[1] = cursos2;

 arrayCursos[2] = new Curso(){
     Nombre = "303",
     Jornada = TiposJornada.Noche
 };

*/

/* Agregando cursos utilizando listas List<>

 var listas1 = new List<Curso>(){
     new Curso(){Nombre = "505"},
     new Curso(){Nombre = "506"},
     new Curso(){Nombre = "507"}

 };

 var listas2 = new List<Curso>(){
     new Curso(){Nombre="401"},
     new Curso(){Nombre="402"}
 };
 listas1.Add(new Curso{Nombre="508"});

*/

/*Agregando cursos Escuela

//es.Cursos.Add(new Curso(){Nombre="401", Jornada = TiposJornada.Manaña});

*/
/* Agregando cursos a otra lista existente

 listas1.AddRange(listas2);
 listas1.RemoveAll(delegate (Curso cur){
                 return cur.Nombre=="402";
                 });
*/

/* Eliminar un curso con un nombre especifico

  listas1.RemoveAll((cur) => cur.Nombre.Equals("506"));

*/

// SALIDAS

// Console.WriteLine(es.Nombres);
// Console.WriteLine("=======================================");
// Console.WriteLine(cursos1.Nombre + "," + cursos1.Jornada + "," + cursos1.CursoId);
// Console.WriteLine($"{curso2.Nombre} , {curso2.Jornada} , {curso2.CursoId}");

// if(es?.Cursos != null){
//     ImprimirCurosNoche(arrayCursos);
// }

// Console.WriteLine("========================================");

// foreach(var list in listas1){
//      Console.WriteLine($"Salon: {list.Nombre} ");
// }

// void ImprimirCurosNoche(Curso[] arrayCursos)
// {
    
//     foreach(var curso in arrayCursos){
//         Console.WriteLine($"Nombre: {curso.Nombre} , Jornada: {curso.Jornada}, Id: {curso.CursoId}");
//     }
// }

Excelente la clase!!

Excelente curso

392*… :B

Yo estoy diseñando el Liceo en Windows Form y con lo aprendido aqui se esta poniendo interesante

Yo estoy creando C# Academy con materias de programación y computer science.

Excelente Profe!

Para generar aleatorios existen algo que es ramdom

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

Si esta algo complicado, voy algo perdido pero espero entenderlo

Excelente!

Excelente Curso!

Buenas clases

Yo estoy creando mi Universidad xd

Vengo de Java y ha sido un poco complejo adaptarme a esta nueva forma de programar, pero todo lo estoy comprendiendo bastante bien…

uve algunos problemas … por que xd

Habia que crear algo? :v

estoy con oxigene pero trato de adaptar esto a un sistema de facturación.

Gracias Juank.

Excelente!!

El curso es muy bueno.

Excelentes explicaciones del profe de como usar las diferentes herramientas que hemos aprendido

Todos los ejemplos son aplicables en proyectos de la vida real, trabajar con estructuras de datos, listas, etc. Buen curso.

Pues yo tengo una idea de crear un sistema completo en el cual nos permita crear una escuela mediante el ingreso de datos en la terminal ademas de tener multiples opciones que ejecutar una vez dentro de ella. En dos o tres horas que lo termine pienso agregarlo a un repositorio y compartirlo junto con el examen final 😄

Esta clase estuvo muy buena, encuentro muy divertido jugar con los nombres aleatorios.

Que buena implementación de las funciones. Se aprende bastante con estos ejemplos.

A nuestro método de CargarAlumnos vamos a añadirle la lógica para pasarle un parámetro indicando la cantidad de alumnos que queremos devuelta y para evitar que siempre nos regrese a los mismos alumnos debe generarlos de forma aleatoria.

La clase Random nos sirve para generar números aleatorios.

Este es mi metodo de imprision por curso, asignatura y alumnos

public static void Impresion(List<Curso> listCurso)
        {

            foreach (Curso curso in listCurso)
            {
                Printer.Dibujar();
                System.Console.WriteLine($"Curso: {curso.Nombre}");
                 Printer.Dibujar();
                 System.Console.WriteLine("");
                foreach (var asa in curso.Asignaturas)
                {
                    System.Console.WriteLine($"Asignatura: {asa.Nombre}");
                }
                Printer.Dibujar();
                 System.Console.WriteLine("");
                foreach (var al in curso.Alumnos)
                {
                    System.Console.WriteLine($"Alumno: {al.Nombre}");
                }
                
            }
        }

tengo un error en genera alumnos me cuando pongo la listaAlumnos en el return me dice que no puede convertir implicitamente al list<t> .de un iEnumerable a alguien le paso lo mismo?

private list<Alumno> GeneraAlumnos(int cantidad)
        {

            string[] nombre1 = { "Alba", "Felipa", "Eusebio", "Farid", "Donald", "Alvaro", "Nicolás" };
            string[] nombre2 = { "Freddy", "Anabel", "Rick", "Murty", "Silvana", "Diomedes", "Nicomedes", "Teodoro" };
            string[] apellido1 = { "Ruiz", "Sarmiento", "Uribe", "Maduro", "Trump", "Toledo", "Herrera" };


            var listaDeAlumnos = from n1 in nombre1
                                 from n2 in nombre2
                                 from a1 in apellido1
                                 select new Alumno { Nombre = $"{n1} {n2} {a1}"};

            return listaDeAlumnos.ToList();
            
        }

Creo que debió generar **una única vez **los alumnos y de forma aleatoria seleccionar n.

Excelente curso! felicidades por este taller

Por si alguien quiere ver como imprimir el listado de asignaturas por curso y alumnos:

Tambien pueden crear todo lo que se ha realizado en distintos metodos en uno solo. Para esto yo utilicé el mismo método de cargar alumno y así evitar crear demás métodos y asignaciones que al final me sirve para cargar los alumnos:

private void CargarAlumnos()
{
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 { Nombre = $"{n1} {n2} {a1}" };

        foreach (var curso in Escuela.Cursos)
        {
            curso.Alumnos = (listaAlumnos.OrderBy((a) => a.UniqueId).Take(new Random().Next(5, 20)).ToList());
        }
    }

Otra manera de solucionar el problema del objeto no inicializado en los primeros dos minutos del video, es asignandolo justamente en cuanto se creo, como se realizo para la carga de cursos.

private void CargarMaterias()
 {
   foreach (var grupo in escuela.Grupo)
    {
       grupo.Materias  = new List<Materia>(){
           new Materia { Nombre = "Biologia"},
           new Materia{ Nombre = "Matematicas"},
           new Materia{ Nombre = "Electronica"},
           new Materia{ Nombre = "Programación"}
         };               
    }
 }

Notese que yo las asignaturas las llamo Materias y a los cursos como grupos.

Me gusta mucho la forma en que Juan Carlos imparte el curso, estoy comprendiendo el porque de utilizar algunos atributos o métodos que alguna vez los usé sin saber a fondo para que servían. Yo le incluí la materia de Inglés.

Resumen Etapa4