Inicialización de arreglos y control de null en C#

Contenido del curso

Introducción al curso

Clases y Objetos

Aprendamos con un proyecto

10
Proyecto Core Escuela: C# con propósito
01:27 min

Etapa 1 – Creando la escuela

Etapa 2 – Creando Cursos para la escuela

Etapa 3 – Implementado colecciones para el manejo de cursos

Etapa 4 – Refactorizando y cargando datos de prueba

El gran RETO

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0015:20

Inicialización de arreglos y control de null en C#

Fundamentos de C# con NET Core 2.1

Clase 18 de 32

Clase 18 / 32

Recursos

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:

// 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.

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:

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.

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.

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.

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.

// 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.