Arreglos (Arrays) en C#

Aprende arreglos en C#: declaración, índices, recorridos con bucles y operaciones básicas con ejemplos prácticos.

En C#, los arreglos (arrays) se utilizan para almacenar múltiples valores del mismo tipo de manera consecutiva en la memoria. Gracias a la indexación, se puede acceder rápidamente a los elementos. Este artículo ofrece una introducción detallada: desde la declaración de arreglos hasta los arreglos multidimensionales, pasando por los métodos de la clase Array y ejemplos prácticos.

¿Qué es un arreglo?

Un arreglo es una estructura donde los datos del mismo tipo se almacenan en celdas de memoria consecutivas. Cada elemento se accede mediante un índice. Los índices comienzan en 0.


int[] numeros = new int[5]; // un arreglo de 5 enteros

Declaración y valores predeterminados

Al declarar un arreglo, se debe especificar su tamaño. Si no se asignan valores, se aplican los valores por defecto:

int → 0
bool → false
string → null


string[] nombres = new string[3];
Console.WriteLine(nombres[0]); // null

Asignación y acceso (Indexación)

Los elementos se acceden a través de su índice. Como los índices empiezan en 0, el último elemento está en Length - 1.


int[] notas = new int[5];
notas[0] = 85;
notas[1] = 90;
notas[2] = 70;
notas[3] = 75;
notas[4] = 60;

Console.WriteLine(notas[1]);  // 90
Console.WriteLine(notas[^1]); // 60, Devuelve el último elemento (Length - 1)

int[] subNotas = notas[1..4]; // Un subarreglo: 90, 70, 75

notas[5] = 100; // Esta línea lanza IndexOutOfRangeException

Acceder o asignar fuera del tamaño del arreglo provoca un error IndexOutOfRangeException. Por ejemplo, para array[4], los índices válidos son 0, 1, 2, 3. Valores como -1, 4 o 5 generan error. El primer elemento siempre se accede con el índice 0.

Atajos de inicialización

Se pueden asignar directamente los valores al crear un arreglo.


int[] numeros = { 10, 20, 30 };
var letras = new char[] { 'A', 'B', 'C' };

Recorrer un arreglo con bucles

Para recorrer un arreglo se utilizan los bucles for y foreach.


int[] numeros = { 3, 6, 9 };

// con for
for (int i = 0; i < numeros.Length; i++)
    Console.WriteLine(numeros[i]);

// con foreach
foreach (var n in numeros)
    Console.WriteLine(n);

Arreglos multidimensionales (2D, 3D)

Los arreglos multidimensionales se usan para almacenar datos en forma de tablas o matrices. Se accede a sus elementos mediante índices o se recorren con bucles anidados.


int[,] matriz = new int[2, 3]
{
    {1, 2, 3},
    {4, 5, 6}
};

Console.WriteLine(matriz[1, 2]); // 6

// Bucles for anidados
for (int i = 0; i < matriz.GetLength(0); i++) // filas
{
    for (int j = 0; j < matriz.GetLength(1); j++) // columnas
    {
        Console.Write(matriz[i, j] + " ");
    }
    Console.WriteLine();
}


// Salida:
6
1 2 3 
4 5 6

Arreglos irregulares (Jagged Arrays)

En un arreglo irregular, cada fila puede tener una longitud diferente. Esto lo diferencia de una matriz.


int[][] jagged = new int[3][];
jagged[0] = new int[] {1, 2};
jagged[1] = new int[] {3, 4, 5};
jagged[2] = new int[] {6};

Console.WriteLine(jagged[1][2]); // 5

La clase Array y métodos útiles

En C#, todos los arreglos heredan de la clase Array. Algunos métodos comunes son:


int[] numeros = { 5, 2, 9, 1, 7 };

Array.Sort(numeros);    // Ordenar
Array.Reverse(numeros); // Invertir
int indice = Array.IndexOf(numeros, 9); // Buscar un elemento

Console.WriteLine(indice);

Ejemplo: Notas de estudiantes

En el siguiente ejemplo, las notas de los estudiantes se almacenan en un arreglo y se calcula el promedio.


int[] notas = { 80, 70, 95, 60, 100 };

int suma = 0;
foreach (var n in notas)
    suma += n;

double promedio = (double)suma / notas.Length;
Console.WriteLine($"Promedio: {promedio}");

TL;DR

Los arreglos almacenan datos del mismo tipo de forma consecutiva en memoria.
Los índices comienzan en 0; los valores por defecto dependen del tipo.
Se pueden recorrer con for y foreach.
Se admiten arreglos multidimensionales e irregulares (jagged).
La clase Array proporciona métodos útiles.

Ejemplo: Puntuaciones de concursantes

En este ejemplo, el usuario introduce el número de concursantes y sus puntuaciones. Luego el programa calcula el total y el promedio. Se usa int.TryParse para verificar que los valores introducidos sean enteros válidos.


using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] puntuaciones = null;
        int cantidad = 0;
        Console.Write("Número de concursantes: ");

        // Leer entrada como string y convertirla a int
        if (!int.TryParse(Console.ReadLine(), out cantidad))
        {
            // Si la conversión falla → terminar el programa con mensaje
            Console.WriteLine("\n\nSe ingresó un valor no entero.");
            return;
        }
        else if (cantidad > 10 || cantidad < 3)
        {
            // Si el valor es válido pero fuera del rango 3–10 → inválido
            Console.WriteLine("\n\nNúmero inválido de concursantes.");
            return;
        }

        // Valor válido → crear un arreglo del tamaño dado
        puntuaciones = new int[cantidad];
        int i = 0;

        // Inicio del bucle
        while (i < puntuaciones.Length)
        {
            // Introducir puntuación de cada concursante
            Console.Write($"{i + 1}. concursante: ");
            if (!int.TryParse(Console.ReadLine(), out puntuaciones[i]))
            {
                // Si el valor no es válido → terminar con mensaje
                Console.WriteLine("\n\nSe ingresó un valor no entero.");
                break;
            }
            i++;
        }

        // Después del bucle, mostrar total y promedio
        Console.WriteLine($"Puntuación total: {puntuaciones.Sum()}");
        Console.WriteLine($"Promedio de puntuaciones: {puntuaciones.Average()}");
    }
}