Domina cómo manejar múltiples cursos en C# con arreglos, evitando fallos por índices incorrectos y formateando la salida con claridad. Verás cómo crear y llenar un arreglo, recorrerlo con la palabra clave while, usar Length para no pasarte del límite y aplicar interpolación de cadenas para imprimir nombre e ID aleatorio de cada curso. Además, aprovecharás atajos del IDE y mejoras de sintaxis.

¿Cómo crear un arreglo de cursos en C#?

Para administrar varios objetos del mismo tipo, usa un arreglo (también llamado array). Un arreglo alinea en memoria elementos del mismo tipo y permite tratarlos como una sola entidad. Recuerda: la numeración inicia en 0.

• Declarar y reservar espacio para tres cursos.
• Asignar cada curso a su posición: 0, 1 y 2.
• Tener presente que empezar desde 1 es un error común.

fullscreen
// Crear y poblar el arreglo de cursos
Curso[] arregloCursos = new Curso[3];

arregloCursos[0] = curso1; // primera posición (índice 0)
arregloCursos[1] = curso2; // segunda posición (índice 1)
arregloCursos[2] = new Curso { Nombre = "Curso 301" }; // tercera posición (índice 2)

• Cada curso muestra un ID aleatorio muy grande con probabilidad ínfima de repetirse.
• Ejecuta y verifica desde la terminal.

fullscreen
dotnet run

¿Cómo recorrer un arreglo con while sin errores?

Imprimir posiciones fijas (0, 1, 2…) funciona, pero es frágil: si pides una posición que no existe, el programa se rompe. La solución es controlar el recorrido con un contador y la propiedad Length del arreglo.

• Iniciar contador en 0.
• Repetir mientras contador < arreglo.Length.
• Imprimir con string interpolation usando el prefijo $.
• Incrementar el contador al final del ciclo.

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

// Pausa opcional antes de continuar
Console.WriteLine("Presione enter para continuar.");
Console.ReadLine();

// Cuidado: esto rompe si la posición no existe
// Console.WriteLine(arregloCursos[5].Nombre);

• Beneficio clave: al usar Length, nunca te sales del rango del arreglo.
• La salida queda consistente y legible con el formato Nombre [..], ID [..].

¿Qué atajos y mejoras de sintaxis aceleran tu código?

Pequeños cambios hacen el código más claro y corto, sin perder legibilidad.

• Incrementos equivalentes.

fullscreen
contador = contador + 1; // forma completa
contador += 1;           // abreviada
contador++;              // la más concisa cuando incrementas de a 1

• Saltos personalizados: puedes avanzar de dos en dos, o de cinco en cinco.

fullscreen
contador += 2; // imprime cada dos posiciones

• Generación de métodos con el IDE: atajo Control + . para crear el esqueleto de un método como ImprimirCursos.
• Nota de práctica: más adelante, los arreglos se usan en casos específicos, pero hoy son ideales para entender índices, longitudes y ciclos.

¿Qué habilidades y keywords refuerzas aquí?

• Uso de arreglos / array para agrupar objetos del mismo tipo.
• Índices desde 0 y cuidado con posiciones inexistentes.
• Ciclo while con contador y condición basada en Length.
• Console.WriteLine con interpolación de cadenas: $"...{expresión}...".
• Console.ReadLine para pausar la ejecución.
• Comandos de compilación/ejecución: dotnet run.
• IDs aleatorios en cursos con bajísima probabilidad de repetición.
• Atajos del IDE y de incremento: +=, ++.

¿Tienes otra forma favorita de recorrer arreglos o formatear la salida? Comparte tu enfoque y qué te gustaría automatizar a continuación.