Es posible escribir C# más claro, compacto y seguro cuando entendemos cómo inicializar arreglos, asignarlos a propiedades y manejar null sin errores. Aquí verás cómo refactorizar código paso a paso, crear un método para imprimir cursos y aplicar atajos como using static y el operador de interrogación para mejorar la legibilidad.

¿Cómo inicializar arreglos en C# de forma limpia?

Un código compacto debe favorecer la legibilidad. No siempre lo más corto se entiende mejor. La idea es equilibrar claridad y brevedad.

¿Qué formas de inicialización mejoran la legibilidad?

• Declarar y poblar el arreglo en una sola expresión.
• Evitar dispersar variables que no se usan.
• Mantener una estructura consistente para leerlo fácil.

Ejemplos equivalentes:

fullscreen
// Especificando tamaño y elementos
auto cursos = new Curso[3] { curso101, curso2, curso3 };

// Omite el tamaño si ya pasas los elementos (el "3" sobra)
var cursos = new Curso[] { curso101, curso2, curso3 };

// Tipo explícito y sin "new" redundante
Curso[] cursos = { curso101, curso2, curso3 };

¿Por qué evitar redundancia al declarar tamaño?

• Si ya agregas 3 elementos, no necesitas indicar [3] explícitamente.
• Reducir ruido visual ayuda a mantener el código claro.

¿Cuándo usar var vs tipo explícito?

• var es válido cuando el tipo es evidente por la derecha.
• Si prefieres claridad explícita, usa Curso[].

¿Cómo asignar arreglos a propiedades y refactorizar la impresión?

Una vez creado el arreglo, puedes asignarlo a la escuela y encapsular la impresión en un método reusable.

¿Cómo imprimir cursos de una escuela con un método?

• Extrae la lógica en un método con un nombre claro.
• Agrega un título para dar contexto.

fullscreen
void ImprimirCursosEscuela(Escuela escuela)
{
    Console.WriteLine("====================");
    Console.WriteLine("Cursos de la escuela");
    Console.WriteLine("====================");

    foreach (var curso in escuela.Cursos)
    {
        Console.WriteLine(curso);
    }
}

Asignación típica del arreglo a la propiedad:

fullscreen
escuela.Cursos = new Curso[] { curso101, curso2, curso3 };

¿Qué aporta using static System.Console?

• Con using static System.Console; puedes escribir menos.
• Evita repetir Console. en cada línea.

fullscreen
using static System.Console;

void ImprimirCursosEscuela(Escuela escuela)
{
    WriteLine("====================");
    WriteLine("Cursos de la escuela");
    WriteLine("====================");

    foreach (var curso in escuela.Cursos)
    {
        WriteLine(curso);
    }
}

¿Cómo reducir código repetitivo en WriteLine?

• Reemplaza Console.WriteLine por WriteLine tras el using static.
• Menos ruido, misma intención. Más legible.

¿Cómo manejar null con seguridad y código compacto?

Los errores por NullReference ocurren cuando iteras o accedes a propiedades sin inicializarlas. Diferencia entre null y arreglo vacío.

¿Qué diferencia hay entre null y arreglo vacío?

• null: no hay referencia. Iterar rompe el programa.
• new Curso[0]: arreglo vacío. Iterar no imprime nada, pero no falla.

fullscreen
escuela.Cursos = null;          // peligro: iterar lanza excepción
escuela.Cursos = new Curso[0];  // seguro: foreach no imprime elementos

¿Cómo protegerse con if, operadores ==, != y cortocircuito?

• Verifica escuela != null antes de acceder a sus propiedades.
• Usa && para aprovechar el cortocircuito: si la primera condición falla, no evalúa la segunda.

fullscreen
if (escuela != null && escuela.Cursos != null)
{
    foreach (var curso in escuela.Cursos)
    {
        WriteLine(curso);
    }
}

¿Cómo simplificar con el operador de interrogación?

• El operador ?. evita acceder a miembros cuando la referencia es null.
• Úsalo para accesos seguros a propiedades encadenadas.

fullscreen
// Acceso seguro a la propiedad (no evalúa Cursos si escuela es null)
var cursos = escuela?.Cursos;

// Si necesitas iterar con seguridad, combínalo con coalescencia
foreach (var curso in (escuela?.Cursos) ?? Array.Empty<Curso>())
{
    WriteLine(curso);
}

Ideas clave:

• Inicializa arreglos de forma compacta, sin redundancias.
• Extrae métodos para responsabilidades claras (imprimir cursos).
• Reduce ruido con using static para WriteLine.
• Controla null con if, && (cortocircuito) y ?..

¿Te gustaría ver variantes con filtros, LINQ o validaciones adicionales? Cuéntame en qué parte quieres profundizar y qué error te encuentras al implementar.