Crea un arreglo de objetos

Otra forma de recorrer un arreglo es con un ciclo foreach.

        private static void ImprimirCursos(Curso[] arregloCursos)
        {
            foreach (var item in arregloCursos)
            {
                Console.WriteLine($"Nombre: {item.Nombre}, Id: {item.UniqueId}");
            }
        }

En mi caso lo hice usando listas:

 List<Curso> cursos = new List<Curso>();
 cursos.Add(new Curso(){Nombre = "101"});
 cursos.Add(new Curso(){Nombre = "201"});
 cursos.Add(new Curso(){Nombre = "301"});

 ImprimirCursos(cursos);


  private static void ImprimirCursos(List<Curso> cursos)
        {
            if(cursos != null && cursos.Count > 0)
            {
                foreach (var curso in cursos)
                {
                    Console.WriteLine($"Nombre: {curso.Nombre}, Id: {curso.Id}");
                }
            }
        }
      	

Por si alguien quiere tener alguna idea de como crearlos de manera dinamica, les comparto!

Excelente curso sigo el curso en MAC

        private static void ImprimirCursos(Curso[] arregloCursos)
        {
            for (int i = 0; i < 3; i++)
            {
                System.Console.WriteLine($"{arregloCursos[i].Nombre}, {arregloCursos[i].UniqueId}");
            }
        }
    

Un consejo que no está tan relacionado a la clase, sino a VS Code, es que podemos hacer que las líneas de codigo se corten y se pasen hacia abajo según el ancho de la ventana/pestaña. Esto para no tener un scroll horizontal.

Alt + Z

Una alternativa usando el ciclo foreach

private static void PrintCourse(Course[] courseArray)
        {
            foreach (Course course in courseArray)
            {
                Console.WriteLine($"Course: {course.Name}, id: {course.UniqueId}");
            }
        }```

Yo lo hice con un ciclo for

var arregloCursos = new Curso[3];
            arregloCursos[0] = new Curso(){Nombre="101"};
            arregloCursos[1] = new Curso(){Nombre="201"};
            arregloCursos[2] = new Curso(){Nombre="301"};
            
            for(int i=0; i<arregloCursos.Length;i++){
                Console.WriteLine($"curso: {arregloCursos[0].Nombre}\nId: {arregloCursos[0].UniqueId}");
                System.Console.WriteLine("=========================");
            }

Otra de las formas de imprimir un array es esta:

foreach(Curso c in arrCursos)
                Console.WriteLine($" Curso: {c.Nombre} - {c.UniqueId}");```

Si alguién le interesa otra forma que se podría mostrar la información de los cursos es sobre el método sobre escrito de ToString() en el cual yo lo deje asi:
public override string ToString() {
return $“Nombre: {this.Name} ,Jornada: {this.Scheldure}”;
}

Y cuándo estemos recorriendo el array sólo sería necesario ccolocar el indice del curso:

private static void PrintCourseInfo(Course[] courses)
{
int cont = 0;
while (cont < courses.Length)
{
System.Console.WriteLine(courses[cont]);
cont ++;
}
}

De esta manera imprimirá la información con el formato que está en el metodo sobre escrito.

Aporte de la clase

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

Console.WriteLine("Hello, World!");
Escuela es = new Escuela("Escuela Basicas",1995,TiposEscuela.Primaria);

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


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

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

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

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

output

Pruebas,Manaña,822e56fd-7c1e-45f6-a37a-4b067228164f
102 , Tarde , faf3d262-8aa0-42f4-9ce9-2961b1dcd96d
Nombre: 301 , Jornada: Noche, Id: d688bd51-b520-4e7a-8668-ac1f337e5ccf
Nombre: 302 , Jornada: Noche, Id: a28efa44-6a98-4ce5-90f6-c568e854dedc
Nombre: 303 , Jornada: Noche, Id: 8c5d2f53-d9e3-4d9c-9363-5ddd03105272

Yo recorri y imprimi el arreglo con un ciclo for básico

 for (int x = 0; x < 3; x++) {

Console.WriteLine(arregloCursos[x].Nombre + "," + arregloCursos[x].UniqueId);
 System.Console.WriteLine("===============");

 }

a mi tampoco me funcionan el ctrl + . para poder hacer la funcion, no se que plugin hace falta para esto, ya tengo el C# extensions y nada

VS Code y el compilador no admitieron este método:

 var courses[] = new Curso[3];

pero si este

Curso[] courses = NewMethod();

alternativamente, se puede usar un for:

for (int i = 0; i < arrayCourse.Length; i++)
{
     Console.WriteLine($"Name: {arrayCourse[i].name}, \nId:
{arrayCourse[i].UniqueId}");
}

No me funciona el ctrl + . para crear las funciones 😦

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

var escuela = new Escuela();
escuela.Nombre = "Mi Escuela";
escuela.TipoEscuela = TiposEscuela.Inicial;
escuela.Ciudad = "Santa Cruz";
escuela.Pais = "Bolivia";

var arregloCursos = new Curso[3];

arregloCursos[0] = new Curso()
{
  Nombre = "Primero",
  Paralelo = TiposParalelo.A,
  Turno = TiposTurno.mañana
};

var primeroBPM = new Curso()
{
  Nombre = "Primero",
  Paralelo = TiposParalelo.B,
  Turno = TiposTurno.mañana
};

arregloCursos[1] = primeroBPM;

arregloCursos[2] = new Curso
{
  Nombre = "Segundo",
  Paralelo = TiposParalelo.A,
  Turno = TiposTurno.tarde
};

Console.WriteLine(escuela);
Console.WriteLine("=====================================");
imprimirCursos();

void imprimirCursos()
{
  int contador = 0;
  while (contador < arregloCursos.Length)
  {
    Console.WriteLine(arregloCursos[contador]);
    System.Console.WriteLine("*************************");
    contador++;
  }
}

        public static void ImprimeArreglos(Curso[] cursos){
            Console.WriteLine("=====================");
            for (int i = 0; i < cursos.Length; i++)
            {
                Console.WriteLine(cursos[i]);
            }
        }

Esta fue mi solucion

Les dejo un video del algoritmo insertion sort en C# trabajado con array.
https://youtu.be/5BrUISr2t-s

Otra alternativa es el foreach en remplazo del while:

void ImprimirCursos(Curso[] arregloCursos)
{
    Console.WriteLine("=============CURSOS DISPONIBLES==========");
    foreach(Curso curso in arregloCursos)
    {
        Console.WriteLine($"Id: {curso.UniqueId}");
        Console.WriteLine($"Curso: {curso.Nombre}");
        Console.WriteLine("---------------------------------------");
    }
    
}
ImprimirCursos(arregloCursos);

En el bucle while se puede utilizar el @ para continuar -con la cadena de caracteres a mostrar en consola- en la siguiente línea:

while (contador < arregloCursos.Length)
{
System.Console.WriteLine($@“Nombre: {arregloCursos[contador].Nombre},
id: {arregloCursos[contador].UniqueId}”);
contador++;
}

😎

Excelente explicacion

Yo lo hice de esta forma y también funcionó 😉

private static void ImprimirCursos(Curso[] arregloCursos)
        {
            for (int i = 0; i < arregloCursos.Length; i++)
            {
                Console.WriteLine("Escuela Nro: " + arregloCursos[i].Nombre);
            }
        }

Da nostalgia ver estos cursos, me recuerda a mis primeros semestres de la U, aprendiendo a programar en lenguaje tipado ❤️

A mí se me paró NetCore Host con el

            Console.WriteLine(arregloCursos[5].Nombre);

😂

A chi, que bueno que estudie algoritmos xd

Codigo de operaciones logicas

<private void button4_Click(object sender, EventArgs e)
        {
            /**Lista Lista = new Lista();
            Lista.checkList();**/
            igual();
            sumarAcumalativa();
            restarAcumalativa();
            decrementarAcumalativa();
        }

        private int dato;
       public void igual(String uno="")
        {
            dato = 2;
            Console.WriteLine("Resultado de igual " + (dato = 3));
        }

        public void sumarAcumalativa(String uno = "")
        {
            dato = 2;
            Console.WriteLine("Resultado de sumarAcumalativa " + (dato += 3));
        }
        public void restarAcumalativa(String uno = "")
        {
            dato = 2;
            Console.WriteLine("Resultado de restarAcumalativa " + (dato -= 3));
        }

        public void decrementarAcumalativa(String uno = "")
        {
            dato = 2;
            Console.WriteLine("Resultado de decrementarAcumalativa " + (dato--));
        }>

Resultado de ejecucion
’Estudiantes.exe’ (CLR v4.0.30319: DefaultDomain): ‘C:\Windows\Microsoft.Net\assembly\GAC_32\mscorlib\v4.0_4.0.0.0__b77a5c561934e089\mscorlib.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.
‘Estudiantes.exe’ (CLR v4.0.30319: DefaultDomain): ‘C:\Users\Sem-6-INGENIERIAINDU\source\repos\Estudiantes\Estudiantes\bin\Debug\Estudiantes.exe’ cargado. Símbolos cargados.
‘Estudiantes.exe’ (CLR v4.0.30319: Estudiantes.exe): ‘C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Windows.Forms\v4.0_4.0.0.0__b77a5c561934e089\System.Windows.Forms.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.
‘Estudiantes.exe’ (CLR v4.0.30319: Estudiantes.exe): ‘C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System\v4.0_4.0.0.0__b77a5c561934e089\System.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.
‘Estudiantes.exe’ (CLR v4.0.30319: Estudiantes.exe): ‘C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Drawing\v4.0_4.0.0.0__b03f5f7f11d50a3a\System.Drawing.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.
‘Estudiantes.exe’ (CLR v4.0.30319: Estudiantes.exe): ‘C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Configuration\v4.0_4.0.0.0__b03f5f7f11d50a3a\System.Configuration.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.
‘Estudiantes.exe’ (CLR v4.0.30319: Estudiantes.exe): ‘C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Core\v4.0_4.0.0.0__b77a5c561934e089\System.Core.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.
‘Estudiantes.exe’ (CLR v4.0.30319: Estudiantes.exe): ‘C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Xml\v4.0_4.0.0.0__b77a5c561934e089\System.Xml.dll’ cargado. Se omitió la carga de símbolos. El módulo está optimizado y la opción del depurador ‘Sólo mi código’ está habilitada.

Resultado de igual 3
Resultado de sumarAcumalativa 5
Resultado de restarAcumalativa -1
Resultado de decrementarAcumalativa 2

Otra forma podría ser

 private static void ImprimirCursos(Curso[] arregloCursos) {
         for (int i = 0; i < arregloCursos.Length; i++) {
                 Console.WriteLine(arregloCursos[i].Nombre);
            }    
        }

Hola compañeros la forma en la que implemente la impresión del arregloCursos fue la siguiente

for (int i = 0; i < arregloCursos.Length; i++)
{
    Console.WriteLine(arregloCursos[i].Nombre + " , " + 			 
      arregloCursos[i].UniqueId);
                
 }

Hola, les comparto un método estático que implementé en la clase principal para imprimir el array de cursos mediante el ciclo for:

Excelente, casi todas usan for, por eso me gusta que use cosas diferentes, hace mas interesante el curso!

Que extension debo instalar para que me cree el constructor automaticamente?

Como podria hacer para autogenerar la cantidad de objetos , y que se impriman con solo una linea de codigo.?

contador = contador + 1 -> contador += 1 -> contador++
contador = contador - 1 -> contador -= 1 -> contador–

Buenas clases

el curso esta interesante

Vaya, que forma de hacer el curso, pero voy entendiendo bien

ahí voy recibiendo información nueva pero interesante

Excelente clase!
Continuamos aprendiendo 😃

using System;
using CorEscuela.Entidades;

namespace Etapa1
{
class Program
{
static void Main(string[] args)
{
//Creacion de un Constructor

        var escuela = new Escuela("Platzi Academy", 2012);
        escuela.NombreEscuela="Platzi Academy"; 
        escuela.Pais="Colombia";
        escuela.Ciudad="Bogota";  
        escuela.TipoEscuela = TiposEscuela.Primaria;         
        
        //Arreglos en C#
        var arregloCursos = new Cursos[3];

       arregloCursos[0] = new Cursos()
                        {
                            Nombre = "101"
                        };

        arregloCursos[1] = new Cursos()
                        {
                            Nombre = "201"
                        }; 

        arregloCursos[2] = new Cursos()
                        {
                            Nombre = "301"
                        };                               

        Console.WriteLine(escuela);

        System.Console.WriteLine("***************************************");
        ImprimirCursos(arregloCursos);

    }

    //Impresion de Arreglos 
    private static void ImprimirCursos(Cursos[] arregloCursos)
    {
        int contador = 0;
        while (contador < arregloCursos.Length)
        {
            System.Console.WriteLine($"Nombre {arregloCursos[contador].Nombre}, Id {arregloCursos[contador].UniqueId}");
            contador +=1;
        }
    }
}

}

Considero que en este tipo de temas deberían ser un poco mas profundos a la hora de explicar estos conceptos. Por lo menos explicar los patrones de recorrido y sus tipos.

Yo use este ejemplo para entender mejor los areglos,

using System;
using ALF.pp;

namespace ejecricio_2
{
class Program
{
static void Main(string[] args)
{
var prueba = new print(“Jose Alejandro”);
// prueba.Alumno();
//prueba.Nombre= “José”;
prueba.tipo=tiposP.ale;
Console.WriteLine(prueba);
string[] ar;
ar = new string[3];
ar[0]=“Juan”;
ar[1]=“hola”;
ar[2]=“casa”;
// ar[3]=“Pelado”;

       for (int i = 0; i < 3; i++)
       {
       Console.WriteLine(ar[i]);
       }
    }
    
}

}

Console.WriteLine("=========================");
var arregloCursos = new Curso[3];
for (int i = 0; i < arregloCursos.Length; i++)
{
arregloCursos[i] = new Curso()
{
Nombre = (i+1).ToString()+“01”
};
}
for (int i = 0; i < arregloCursos.Length; i++)
{
Console.WriteLine($“Curso: {arregloCursos[i].Nombre}, ID: {arregloCursos[i].UniqueId}”);
}

foreach (var curso in arregloCursos)
{
Console.WriteLine(curso.Nombre + " , " + curso.UniqueId);
Console.WriteLine(“Presione enter para continuar…”);
Console.ReadLine();
}

 static void Main (string[] args) 
        {
            var schoolCopy1 = new SchoolPrototype("music academy", SchoolTypes.basic, 1820);
            var coursesArray = new CoursePrototype[3];
            coursesArray[0] = new CoursePrototype("course1");
            coursesArray[1] = new CoursePrototype("course2");
            coursesArray[2] = new CoursePrototype("course3");
            Console.WriteLine (schoolCopy1);
            printCourses(coursesArray);
            
        }
se me hizo mas fácil hacer el array de esta manera, solo le pones el parámetro (nombre del curso), y ya dentro de la clase lo asignas a la prop Nombre```

Muy buena demostración para recorrer arreglos

enjava ArrayList

excelwnte

Excelente explicación.

Así queda el for:

 private static void Imprimircursos(Curso[] arregloCursos)
    {
       for (int i =0; i< arregloCursos.Length;i++ )
           {
            System.Console.WriteLine($"{arregloCursos[i].Nombre} , {arregloCursos[i].UniqueId }");
           }
    }

Como que me gusta usar más un foreach, quedó así:

foreach(var course in courseArray){
                System.Console.WriteLine("***---***---***");
                System.Console.WriteLine("Course name: " + course.Name);
                System.Console.WriteLine("Course ID: " + course.UniqueId);
            }

        private static void ImprimirCursos(Curso[] arregloCursos)
        {
            int contador = 0;
            while (contador < arregloCursos.Length)
            {
                Console.WriteLine($"Nombre: {arregloCursos[contador].Nombre}, ID: {arregloCursos[contador].UniqueId}");
                contador++;
            }
        }

También se podría:
contador -=- contador;
Es simétrico, es perfecto

contador -=- contador;
es igual a:
contador = contador - (-contador);
que es igual a:
contador = contador + contador;
que es igual a:
contador += contador;
que es igual a:
contador++;

using System;
using CoreEscuela.Entidades;

namespace Etapa1
{
    class Program
    {
        static void Main(string[] args)
        {
            var escuela = new Escuela("Escuela SCJ",2010,TiposEscuela.Primaria, 
            ciudad:"Santiago", pais:"Chile"
            );

            var arreglosCursos = new Curso[3];

            arreglosCursos[0] = new Curso()
            {
                Nombre="101"
            };

            var cursos2 = new Curso()
            {
                Nombre="201"
            };

            arreglosCursos[1] = cursos2;

            arreglosCursos[2] = new Curso
            {
                Nombre="301"
            };

            Console.WriteLine(escuela);
            System.Console.WriteLine("===============================================");

            ImprimirCursos(arreglosCursos);
            
        }

        private static void ImprimirCursos(Curso[] arreglosCursos)
        {
            int contador = 0;
            while (contador < arreglosCursos.Length)
            {

                System.Console.WriteLine(  $"Nombre: {arreglosCursos[contador].Nombre}, Id: {arreglosCursos[contador].UniqueId}");
                contador++;
            }
        }
    }
}

Les comparto una alternativa usando el ciclo for:

private static void IprimirCursos(Curso[] arrCursos)
        {
            int countCursos = arrCursos.Length;
            for (int i = 0; i < countCursos; i++)
            {
                System.Console.WriteLine($"Curso: {arrCursos[i].Nombre}, id: {arrCursos[i].UniqueId}");
            }
        }

**Tip: **La variable countCursos la defino para que en cada iteración, no sea necesario preguntar por el largo que tiene el arreglo, aunque es algo muy pequeño, ayuda a optimizar el código 😃

Un arreglo o array es una entidad donde podemos alinear varios objetos del mismo tipo en memoria. La posición en un arreglo arranca desde 0, entonces en un arreglo cuyo tamaño es 3 la última posición seria 2.

Existen muchas formas de recorrer un arreglo, entre ellas se encuentra la sentencia while que va a ejecutarse hasta que su condición se termine, en este caso se termina de ejecutar hasta que haya recorrido todo el arreglo.

otra forma de recorrer el arreglo con for

private static void imprimirCursos(curso[] arregloCursos)
        {
            for (int i = 0; i < arregloCursos.Length; i++)
            {
                Console.WriteLine($"nombre: {arregloCursos[i].nombre}, id: {arregloCursos[i].UniqueId}");
            }
        }

Yo aqui cree un pequeño metodo para permitir el ingreso de varios cursos:

      private static Curso[] ingresarCursos()
        {
            Console.WriteLine("Ingrese la cantidad de cursos que desea ingresar");
            var n = Convert.ToInt32(Console.ReadLine());
            var arrCursos = new Curso[n];
            for (int i = 0; i < n; i++)
            {
                Console.WriteLine("Ingrese el nombre del curso a ingresar");
                arrCursos[i] = new Curso
                {
                  Nombre=  Convert.ToString(Console.ReadLine())
                };
                
            }
            return arrCursos;
        }

y luego para poder llamarlo desde el principal:

  var arrayCursos = new Curso[0];

            arrayCursos = ingresarCursos();

lo voy a hacer con listas y un foreach

Si lo quiero hacer por medio de Visual Studio Community 2019 como puedo asociar el namespace CoreEscuela.Entidades en Program.cs??
No me funciona con el using CoreEscuela.Entidades 😦