Formas de recorrer arreglos

El bucle ForEach fue principalmente hecho para recorrer arrays

al medir el tiempo de ejecuccion es mucha la diferencia.

PS C:\Users\Raziel214\Documents\GitHub\COREESCUELA> dotnet run
Nombre: "Copia:JOHN'S SCHOOL", Tipo: Primaria
,Pais: Colombia,Ciudad: cali
#############
Nombre101,Id 24f57c62-efe0-4788-a616-36ddc9f3c3de
Nombre201,Id 9ca95e12-dc0a-4c21-9d18-425ad2c556ae
Nombre301,Id 0b109791-5c1a-40be-8d92-746e89dfd0fe
4.2076
#############
Nombre101,Id 24f57c62-efe0-4788-a616-36ddc9f3c3de
Nombre201,Id 9ca95e12-dc0a-4c21-9d18-425ad2c556ae
Nombre301,Id 0b109791-5c1a-40be-8d92-746e89dfd0fe
0.8204

Los separadores también se pueden hacer de la siguiente forma:

string separador = String.Concat(Enumerable.Repeat("=", 20));

En este caso “Enumerable” es una función de Linq, por lo que tenemos que agregar esto:

using System.Linq;

Sino, también podemos hacerlo de la siguiente forma:

string separador2 = new string ('*', 20);

Y después solamente las ejecutamos con el WriteLine:

Console.WriteLine(separador2);
Console.WriteLine(separador);

Si lo dejan el Do while con (contador++ <arregloCursos.Legth)

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

Al final le indicara que no encontró la última posición y que se salió del arreglo, debido a que cuando contador=2 es < que arregloCursos.Legth y vuelve a hacer una vuelta extra pero ahora es contador=3; debido a que le sumo 1 después de hacer la comparación, y el arreglo ya no tiene posición 3 por eso hay que tener cuidado de donde se coloca el contador++ como bien mencionó el profesor.

En mi opinion, tratar de hacer el codigo mas “simple” o “legible”, a veces lo complica mas, yo pienso que el codigo mas simple o legible es el que puede leer una persona que no sea necesariamente experto en el lenguaje.

**Dato interesante: ** En el For Each Juan Carlos decidió usar VAR como el tipo de cada uno de los elementos en el arreglo. Esto es posible porque VAR es mas general y recibe mas tipos de datos/objetos.

foreach (var curso in cursoArreglo)
            {
                Console.WriteLine($"{curso.nombre}, {curso.id}");
            }

Pero también es posible usar el tipo de la variable que ya sabes que se encuentra dentro del arreglo, en este caso el tipo Curso. Quedando de esta manera:

foreach (Curso curso in cursoArreglo)
            {
                Console.WriteLine($"{curso.nombre}, {curso.id");
            }

Importante decir que con do…while, lo que esta dentro del do se ejecuta al menos una vez SIEMPRE, sin importar la condicion de while.

En el DoWhile si escribimos incrementando el contador dentro del While pero haciendo el incremento después de que se ejecute la pregunta el código arroja un error porque el contador va a valer 3 y al querer ejecutar el array de máximo 2 va a fallar.

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

Si que me está agradando la manera de entender las diferencias y en que casos podemos utilizar un arreglo.

Rename Symbol F2 para cambiar los demas lugares donde se llama un metodo.

**Prefijo: ** ++contador (primero se asigna el valor de incremento para posteriormente realizar la operación).
**Posfijo: ** contador ++ (se realiza la operación y luego se suma para almacenarse el valor).

Hola. El profesor menciona que el foreach a nivel de memoria cambia bastante. ¿Alguien sabe los detalles técnicos de esta diferencia que menciona el profesor?

Además de recorrer un arreglo con la sentencia while podemos encontrar:

La sentencia do while donde a diferencia de while se va a ejecutar primero el código y luego va a verificar si la condición es válida.
La sentencia for.
La sentencia foreach.

Para que en la impresión podemos identificar cada uno de los diferentes recorridos:

            System.Console.WriteLine("============ Normal");
            Console.WriteLine(escuela);
            System.Console.WriteLine("============ While");
            imprimirCursosWhile(arregloCursos);
            System.Console.WriteLine("============ Do While");
            imprimirCursosDoWhile(arregloCursos);
            System.Console.WriteLine("============ For");
            imprimirCursosFor(arregloCursos);
            System.Console.WriteLine("============ For Each");
            imprimirCursosForEach(arregloCursos);

Es interesante comentar que a nivel de programación si las sentencias de comparación o de bucles solo tiene una instrucción se puede prescindir de los corchetes, así:

    foreach (Curso c in arregloCursos)
                Console.WriteLine(c.Nombre + "," + c.UniqueId);

foreach (Curso curso in array)
 {
      Console.WriteLine($"\n{curso}");
 }

Falta poco

Y si?

public void Imprimir(){
            System.Console.WriteLine($"  {Nombre}  | {UniqueId}");
        }

a la clase objeto y en el programa lo invocamos

while (contador < arregloCursos.Length)
            {
                arregloCursos[contador].Imprimir();
                contador++;
            }

En este caso para poder recorrer los arreglos se puede hacer de la siguiente manera

<for (type var : array) 
{ 
    statements using var;
}
is equivalent to:

for (int i=0; i<arr.length; i++) 
{ 
    type var = arr[i];
    statements using var;
}>

Se podría escribir también como LinQ

private static void ImprimirCursos(Curso[] arregloCursos)
{
	arregloCursos.ToList().ForEach(s => Console.WriteLine(string.Format("{0} | {1}", s._nombre, s._uniqueId)));
}

Excelente!
While
DoWhile
For
Foreach

Buenas clases

Esta es mi manera de recorrer el arreglo
for (int i = 0; i <= arregloCursos.Length; i++)
{
Console.WriteLine("Curso: " + arregloCursos[i].nombre
+ "\nUid: " + arregloCursos[i].uid);
}

Esta es mi manera de recorrer el arreglo
for (int i = 0; i <= arregloCursos.Length; i++)
{
Console.WriteLine("Curso: " + arregloCursos[i].nombre
+ "\nUid: " + arregloCursos[i].uid);
}

Tipos de Sentencias para recorrer una array:

• Do while: a diferencia del while , en esta sentencia el codigo de ejecuta simpre 1 vez, y luego se comprueba la condición

• For: una forma mas compacta de while y mas legible, el inconveniente es que puede ser mas sencillo equivocarse a la hora de escribir el codigo.

• ForEach: la mas fiable y legible es el for.

do{}while se usa cuando queremos una iteracion como minimo,

escuela.TipoEscuela = TipoEscuela.Primaria;
            Console.WriteLine(escuela);
            Console.WriteLine("=============");
            ImprimirCursosWhile(arregloCursos);
            Console.WriteLine("=============");
            ImprimirCursosDoWhile(arregloCursos);
            Console.WriteLine("=============");
            ImprimirCursosFor(arregloCursos);
            Console.WriteLine("=============");
            ImprimirCursosForeach(arregloCursos);
        }

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

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

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

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

Muy buena explicación de como recorrer los arreglos genial!!!

Buena aclaración entre el For y el ForEach

Muy satisfecho, del curso

Muy buena clase! Creando marcador ahora! jaja

Muy buena explicación sobre como recorrer un arreglo de diferentes formas

❤️

Console.WriteLine("===========While=============");
ImprimirCursosWhile(arrayCursos);
Console.WriteLine("===========DoWhile===========");
ImprimirCursosDoWhile(arrayCursos);
Console.WriteLine("===========ForEach============");
ImprimirCursosForEach(arrayCursos);
Console.WriteLine("============For==============");
ImprimirCursosFor(arrayCursos);
        
        private static void ImprimirCursosWhile(Curso[] arrayCursos)
        {
            int contador = 0;
            while (contador < arrayCursos.Length){
                Console.WriteLine($"{arrayCursos[1].Nombre},{arrayCursos[1].Id}");
                contador++;
            }
        }

        private static void ImprimirCursosDoWhile(Curso[] arrayCursos)
        {
            int contador = 0;
            do{
                Console.WriteLine($"{arrayCursos[1].Nombre},{arrayCursos[1].Id}");
                contador++;
            } while (contador < arrayCursos.Length);
        }

        private static void ImprimirCursosForEach(Curso[] arrayCursos)
        {
            foreach (var curso in arrayCursos)
                Console.WriteLine($"{curso.Nombre},{curso.Id}");
        }

        private static void ImprimirCursosFor(Curso[] arrayCursos)
        {
            for(int contador=0; contador < arrayCursos.Length; contador++)
                Console.WriteLine($"{arrayCursos[contador].Nombre},{arrayCursos[contador].Id}");
        }

Me encanta el foreach

private static void printCursosForEach(Curso[] cursosCreados)
        {
            foreach (var item in cursosCreados)
            {
                Console.WriteLine($"Nombre {item.Name} \nID {item.IdCourse}");
            }                            
        }```

Recorriendo Arreglos.

Muy bien

Este curso esta genial, de hecho uno de los mejores, lastima no este en la ruta principal

La diferencia entre while y do while es que en el do while siempre se ejecutará al menos una vez. Por más que de entrada la condición sea false, se ejecutará una vez el código que se encuentra dentro del bucle.

<code> 

private static void imprimirCursos(curso[] arregloCursos)
        {
            // Formas de recorrer un arreglo

            // con for
             for (int i = 0; i < arregloCursos.Length; i++)
                {
                    Console.WriteLine($"Nombre del curso: {arregloCursos[i].nombre} Jornada: {arregloCursos[i].jornada} ID: {arregloCursos[i].uniqueId}");
                }

            // con foreach
            foreach (var curso in arregloCursos)
            {
                if (curso != null)
                {
                    Console.WriteLine($"Nombre del curso: {curso.nombre} Jornada: {curso.jornada} ID: {curso.uniqueId}");
                }
            }

            // con while

            int indice = 0;
            while (indice < arregloCursos.Length)
            {
                Console.WriteLine($"Nombre del curso: {arregloCursos[indice].nombre} Jornada: {arregloCursos[indice].jornada} ID: {arregloCursos[indice].uniqueId}");
                indice++;
            }

            // con do while

            indice = 0;
            do
            {
                Console.WriteLine($"Nombre del curso: {arregloCursos[indice].nombre} Jornada: {arregloCursos[indice].jornada} ID: {arregloCursos[indice].uniqueId}");
                indice++;
            } while (indice < arregloCursos.Length);

        }

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

=======================================
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 usé un foreach

<code> 
static void Imprimir(Curso[] array)
{
    foreach (var arreglo in array)
    {
        Console.WriteLine($"ID: {arreglo.ID} Nombre: {arreglo.Nombre}");
    }
}

private static void ImprimirCursos(Curso[] cursos)
{
	 cursos.AsEnumerable().ToList().ForEach(curso =>
         {
                Console.WriteLine(string.Format("Id: {0}, Nombre: {1}", 				 
		curso.Id, curso.Nombre));
	});
}

Buenísima explicación, en la universidad jamás comprendí sobre los array porque se me hacían super complicados por lo que utilizaba listas, pero después de 5 años, en esta clase entiendo y de una forma sencilla.

Gracias Juan Carlos.

Esta clase esta en los comentarios de la clase anterior 🔥🔥 Aunque hacia falta la explicación del profesor, Genial

Interesante

 static void ImprimirCursosFor( Curso[] Arreglo){
                for (int i=0; i<= Arreglo.Length; i++){
                    Console.WriteLine($"Nombre{Arreglo[i].Nombre} , Id{Arreglo[i].UniqueId}");
                }
            }