Docs ejecutables de C#: Arrays

Q: ¿Cómo obtengo la longitud de un array en C#?

Usa la propiedad Length: scores.Length. Es una propiedad, no un método, así que no lleva paréntesis. En un array 2D, Length es el número total de elementos; usa GetLength(0) para el número de filas y GetLength(1) para el número de columnas.

Q: ¿Cómo ordeno un array en C#?

Array.Sort(arr) ordena el array en el sitio en orden ascendente. Para orden descendente, llama a Array.Reverse(arr) después de ordenar, o pasa una comparación: Array.Sort(arr, (a, b) => b.CompareTo(a)). Para obtener una copia ordenada y conservar el original, usa LINQ: arr.OrderBy(x => x).ToArray().

Q: ¿Qué diferencia hay entre un array 2D y un array escalonado en C#?

Un array 2D int[,] es un único bloque rectangular: todas las filas tienen el mismo número de columnas, y se indexa como grid[row, col]. Un array escalonado int[][] es un array de arrays: cada fila es un array independiente que puede tener su propia longitud, y se indexa como rows[i][j]. Cada fila de un array escalonado debe crearse antes de usarla, o será null.

Q: ¿Se puede cambiar el tamaño de un array en C#?

No. La longitud de un array se fija al crearlo. Array.Resize(ref arr, newSize) parece que cambia el tamaño, pero reserva un array nuevo, copia los elementos y hace que tu variable apunte al nuevo. Si el tamaño cambia a menudo, usa una List .

Q: ¿Por qué al imprimir un array aparece System.Int32[]?

Console.WriteLine(arr) llama a arr.ToString(), y los arrays no lo sobrescriben, así que obtienes el nombre del tipo. Une los elementos en un solo string: Console.WriteLine(string.Join(", ", arr)).

Un array contiene un número fijo de elementos de un tipo, guardados uno al lado del otro en memoria. Eliges la longitud al crearlo, lees y escribes elementos mediante un índice que empieza en cero, y la longitud ya no cambia después.

Declarar e inicializar un array

El tipo de un array es el tipo de elemento seguido de []. Hay varias formas de crear uno:

using System;

class Program
{
    static void Main()
    {
        int[] scores = new int[4];                     // 4 elements, all 0
        string[] names = { "Ana", "Ben", "Chloe" };     // initializer
        double[] prices = new double[] { 2.5, 9.99 };   // explicit form
        var days = new[] { "Mon", "Tue", "Wed" };       // type inferred: string[]

        scores[0] = 90;
        scores[3] = 72;

        Console.WriteLine(string.Join(", ", scores));
        Console.WriteLine(names[1]);
        Console.WriteLine(prices.Length + " prices, " + days.Length + " days");
    }
}

Salida:

90, 0, 0, 72
Ben
2 prices, 3 days

new int[4] llena cada elemento con el valor por defecto del tipo: 0 para los números, false para bool, null para los strings y los demás tipos de referencia. La forma corta { "Ana", "Ben" } solo funciona en una declaración; al asignar a una variable existente necesitas names = new[] { "Dev", "Eli" };.

Length, índices y el último elemento

Los índices van de 0 a Length - 1. Length es una propiedad, así que no lleva paréntesis (a diferencia del método Count() de LINQ).

using System;

class Program
{
    static void Main()
    {
        int[] temps = { 18, 21, 25, 19, 16 };

        Console.WriteLine("Count: " + temps.Length);
        Console.WriteLine("First: " + temps[0]);
        Console.WriteLine("Last: " + temps[temps.Length - 1]);

        try
        {
            Console.WriteLine(temps[5]);
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }
    }
}

Salida:

Count: 5
First: 18
Last: 16
Caught IndexOutOfRangeException

Leer o escribir fuera de los límites lanza IndexOutOfRangeException en tiempo de ejecución; el compilador no lo detecta. La causa habitual es una condición de bucle escrita como i <= arr.Length en lugar de i < arr.Length.

C# 8 y posteriores añaden la sintaxis de índice desde el final y de rangos, más corta para el último elemento y para los fragmentos:

int last = temps[^1];        // 16
int[] middle = temps[1..4];  // { 21, 25, 19 }, a new array

Recorrer un array

Un bucle for te da el índice; foreach te da cada elemento y es la opción más clara cuando solo lees.

using System;

class Program
{
    static void Main()
    {
        decimal[] prices = { 4.50m, 12.00m, 3.25m };

        for (int i = 0; i < prices.Length; i++)
        {
            prices[i] = Math.Round(prices[i] * 1.10m, 2); // raise every price by 10%
        }

        decimal total = 0;
        foreach (decimal p in prices)
        {
            total += p;
        }

        Console.WriteLine(string.Join(" | ", prices));
        Console.WriteLine("Total: " + total);
    }
}

Salida:

4.95 | 13.20 | 3.58
Total: 21.73

La variable de foreach es de solo lectura: p = 0; dentro del bucle es un error de compilación. Para cambiar elementos, recorre con un índice.

Ordenar, invertir y buscar

La clase static Array contiene los métodos auxiliares. Array.Sort ordena en el sitio y no devuelve nada, así que el orden original se pierde.

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 60, 88, 79 };

        Array.Sort(scores);
        Console.WriteLine("Ascending:  " + string.Join(", ", scores));

        Array.Reverse(scores);
        Console.WriteLine("Descending: " + string.Join(", ", scores));

        Console.WriteLine("Index of 60: " + Array.IndexOf(scores, 60));
        Console.WriteLine("Index of 99: " + Array.IndexOf(scores, 99));
        Console.WriteLine("Any above 90: " + Array.Exists(scores, s => s > 90));
        Console.WriteLine("First below 75: " + Array.Find(scores, s => s < 75));

        string[] names = { "chloe", "Ana", "ben" };
        Array.Sort(names, StringComparer.OrdinalIgnoreCase);
        Console.WriteLine(string.Join(", ", names));

        string[] fruits = { "kiwi", "banana", "fig" };
        Array.Sort(fruits, (a, b) => a.Length.CompareTo(b.Length)); // by length
        Console.WriteLine(string.Join(", ", fruits));
    }
}

Salida:

Ascending:  60, 72, 79, 88, 95
Descending: 95, 88, 79, 72, 60
Index of 60: 4
Index of 99: -1
Any above 90: True
First below 75: 72
Ana, ben, chloe
fig, kiwi, banana

Array.IndexOf devuelve -1 cuando el valor no está. Array.Find devuelve el valor por defecto del tipo (0 aquí) cuando nada coincide, lo que resulta ambiguo con números; usa Array.FindIndex cuando eso importe. Una ordenación descendente en una sola llamada es Array.Sort(scores, (a, b) => b.CompareTo(a)).

Si necesitas el resultado ordenado sin tocar el original, LINQ devuelve un array nuevo: var sorted = scores.OrderBy(s => s).ToArray();. Consulta LINQ.

Cambiar el tamaño: un array no puede crecer

La longitud es fija. Array.Resize crea un array nuevo del tamaño pedido, copia los elementos y actualiza la variable que pasas por ref.

using System;

class Program
{
    static void Main()
    {
        string[] queue = { "Ana", "Ben" };
        string[] before = queue;

        Array.Resize(ref queue, 4);
        queue[2] = "Chloe";

        Console.WriteLine(queue.Length);
        Console.WriteLine(before.Length);             // the old array is unchanged
        Console.WriteLine(queue[3] == null);          // new slots get the default
        Console.WriteLine(ReferenceEquals(before, queue));
    }
}

Salida:

4
2
True
False

Cada cambio de tamaño copia todos los elementos. Hacer crecer un array de uno en uno dentro de un bucle es lento, y es justo lo que List<T> hace por ti de forma más eficiente, duplicando su array interno.

Los arrays son tipos de referencia: copiar

Asignar un array a otra variable copia la referencia, no los elementos. Los dos nombres apuntan entonces al mismo array.

using System;

class Program
{
    static void Main()
    {
        int[] original = { 1, 2, 3 };

        int[] alias = original;
        alias[0] = 100;
        Console.WriteLine(original[0]); // 100: same array

        int[] copy = (int[])original.Clone();
        copy[1] = 200;
        Console.WriteLine(original[1]); // 2: independent array

        int[] target = new int[5];
        Array.Copy(original, 0, target, 1, 3); // source, start, dest, start, count
        Console.WriteLine(string.Join(", ", target));
    }
}

Salida:

100
2
0, 100, 2, 3, 0

Lo mismo ocurre cuando pasas un array a un método: el método puede cambiar los elementos de quien llama. Clone, Array.Copy, CopyTo y ToArray() de LINQ hacen todos una copia superficial. En un array de objetos, el array nuevo contiene referencias a los mismos objetos, así que cambiar copy[0].Name sigue cambiando lo que ve original[0].

Comparar arrays con == compara referencias. Para comparar el contenido, usa a.SequenceEqual(b) de System.Linq.

Arrays 2D (multidimensionales)

Una cuadrícula rectangular se declara con una coma dentro de los corchetes. Se indexa con [row, col].

using System;

class Program
{
    static void Main()
    {
        int[,] seats = new int[2, 3]; // 2 rows, 3 columns
        seats[0, 1] = 1;
        seats[1, 2] = 1;

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

        Console.WriteLine("Rows: " + grid.GetLength(0));
        Console.WriteLine("Cols: " + grid.GetLength(1));
        Console.WriteLine("Length: " + grid.Length + ", Rank: " + grid.Rank);

        for (int r = 0; r < seats.GetLength(0); r++)
        {
            for (int c = 0; c < seats.GetLength(1); c++)
            {
                Console.Write(seats[r, c] == 1 ? "X " : ". ");
            }
            Console.WriteLine();
        }
    }
}

Salida:

Rows: 2
Cols: 3
Length: 6, Rank: 2
. X . 
. . X

Length en un array 2D es el número total de elementos (6 en una cuadrícula de 2 por 3), por eso los bucles anidados usan GetLength(0) y GetLength(1). Rank es el número de dimensiones. Tres dimensiones funcionan igual: new int[4, 4, 4] y cube[x, y, z]. Un foreach sobre un array 2D visita todos los elementos fila por fila.

Arrays escalonados (arrays de arrays)

Un array escalonado int[][] es un array cuyos elementos son a su vez arrays, y cada array interior puede tener su propia longitud. Encaja con datos como "pedidos por cliente", donde las filas tienen tamaños distintos.

using System;

class Program
{
    static void Main()
    {
        int[][] orders = new int[3][]; // 3 rows, none created yet
        orders[0] = new[] { 20, 35 };
        orders[1] = new[] { 12 };
        orders[2] = new[] { 8, 15, 40, 22 };

        for (int i = 0; i < orders.Length; i++)
        {
            Console.WriteLine("Customer " + i + ": " + orders[i].Length
                + " orders, " + string.Join(", ", orders[i]));
        }

        int[][] empty = new int[2][];
        Console.WriteLine(empty[0] == null);
    }
}

Salida:

Customer 0: 2 orders, 20, 35
Customer 1: 1 orders, 12
Customer 2: 4 orders, 8, 15, 40, 22
True

new int[3][] crea solo el array exterior; cada fila empieza siendo null, y orders[0][0] antes de asignar una fila lanza NullReferenceException. La sintaxis new int[3][4] no está permitida; tienes que crear cada fila tú.

Usa [,] para una cuadrícula de verdad (un tablero, una matriz, píxeles) y [][] cuando las filas tienen longitudes distintas o quieres intercambiar filas enteras.

Array frente a List

	Array `T[]`	`List<T>`
Tamaño	Fijo al crearlo	Crece y se reduce
Número de elementos	Propiedad `Length`	Propiedad `Count`
Añadir o quitar	No es posible (solo `Array.Resize`)	`Add`, `Insert`, `Remove`
Multidimensional	`[,]` y `[][]`	Solo listas de listas
Uso típico	Tamaño conocido, tablas de consulta, buffers	Colecciones que cambian

Convertir es una llamada en cada sentido: new List<int>(arr) o arr.ToList(), y list.ToArray(). List<T> es la versión que puede crecer.

Errores comunes

i <= arr.Length en un bucle. El último índice válido es Length - 1; esto lanza IndexOutOfRangeException.
Imprimir el array directamente. Console.WriteLine(arr) imprime System.Int32[]; usa string.Join.
Esperar que Array.Sort devuelva el array ordenado. Devuelve void y ordena en el sitio.
Copiar con =. Eso copia la referencia; usa Clone() o ToArray().
Usar filas de un array escalonado antes de crearlas. Cada fila de new T[n][] es null hasta que se asigna.
Usar Length para las filas de un array 2D. Cuenta todos los elementos; usa GetLength(0).

Preguntas frecuentes

¿Cómo obtengo la longitud de un array en C#?

Usa la propiedad Length: scores.Length. Es una propiedad, no un método, así que no lleva paréntesis. En un array 2D, Length es el número total de elementos; usa GetLength(0) para el número de filas y GetLength(1) para el número de columnas.

¿Cómo ordeno un array en C#?

Array.Sort(arr) ordena el array en el sitio en orden ascendente. Para orden descendente, llama a Array.Reverse(arr) después de ordenar, o pasa una comparación: Array.Sort(arr, (a, b) => b.CompareTo(a)). Para obtener una copia ordenada y conservar el original, usa LINQ: arr.OrderBy(x => x).ToArray().

¿Qué diferencia hay entre un array 2D y un array escalonado en C#?

Un array 2D int[,] es un único bloque rectangular: todas las filas tienen el mismo número de columnas, y se indexa como grid[row, col]. Un array escalonado int[][] es un array de arrays: cada fila es un array independiente que puede tener su propia longitud, y se indexa como rows[i][j]. Cada fila de un array escalonado debe crearse antes de usarla, o será null.

¿Se puede cambiar el tamaño de un array en C#?

No. La longitud de un array se fija al crearlo. Array.Resize(ref arr, newSize) parece que cambia el tamaño, pero reserva un array nuevo, copia los elementos y hace que tu variable apunte al nuevo. Si el tamaño cambia a menudo, usa una List<T>.

¿Por qué al imprimir un array aparece System.Int32[]?

Console.WriteLine(arr) llama a arr.ToString(), y los arrays no lo sobrescriben, así que obtienes el nombre del tipo. Une los elementos en un solo string: Console.WriteLine(string.Join(", ", arr)).

¿Debo usar un array o una List en C#?

Usa un array cuando el número de elementos es conocido y fijo, como los 12 meses o un tablero de juego. Usa List<T> cuando se añaden o quitan elementos con el tiempo. Los dos acceden por índice en tiempo constante, y una List<T> guarda sus elementos internamente en un array.

Conceptos relacionados