No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Crea un arreglo de objetos

16/32
Recursos

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.

Aportes 64

Preguntas 9

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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!

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

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

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

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

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 $鈥淣ombre: {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.

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

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("===============");

 }

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

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([email protected]鈥淣ombre: {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
鈥橢studiantes.exe鈥 (CLR v4.0.30319: DefaultDomain): 鈥楥:\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 鈥楽贸lo mi c贸digo鈥 est谩 habilitada.
鈥楨studiantes.exe鈥 (CLR v4.0.30319: DefaultDomain): 鈥楥:\Users\Sem-6-INGENIERIAINDU\source\repos\Estudiantes\Estudiantes\bin\Debug\Estudiantes.exe鈥 cargado. S铆mbolos cargados.
鈥楨studiantes.exe鈥 (CLR v4.0.30319: Estudiantes.exe): 鈥楥:\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 鈥楽贸lo mi c贸digo鈥 est谩 habilitada.
鈥楨studiantes.exe鈥 (CLR v4.0.30319: Estudiantes.exe): 鈥楥:\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 鈥楽贸lo mi c贸digo鈥 est谩 habilitada.
鈥楨studiantes.exe鈥 (CLR v4.0.30319: Estudiantes.exe): 鈥楥:\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 鈥楽贸lo mi c贸digo鈥 est谩 habilitada.
鈥楨studiantes.exe鈥 (CLR v4.0.30319: Estudiantes.exe): 鈥楥:\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 鈥楽贸lo mi c贸digo鈥 est谩 habilitada.
鈥楨studiantes.exe鈥 (CLR v4.0.30319: Estudiantes.exe): 鈥楥:\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 鈥楽贸lo mi c贸digo鈥 est谩 habilitada.
鈥楨studiantes.exe鈥 (CLR v4.0.30319: Estudiantes.exe): 鈥楥:\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 鈥楽贸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(鈥淛ose Alejandro鈥);
// prueba.Alumno();
//prueba.Nombre= 鈥淛os茅鈥;
prueba.tipo=tiposP.ale;
Console.WriteLine(prueba);
string[] ar;
ar = new string[3];
ar[0]=鈥淛uan鈥;
ar[1]=鈥渉ola鈥;
ar[2]=鈥渃asa鈥;
// ar[3]=鈥淧elado鈥;

       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($鈥淐urso: {arregloCursos[i].Nombre}, ID: {arregloCursos[i].UniqueId}鈥);
}

foreach (var curso in arregloCursos)
{
Console.WriteLine(curso.Nombre + " , " + curso.UniqueId);
Console.WriteLine(鈥淧resione 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 馃槮