Matrices

Una matriz es una estructura de datos que contiene una serie de variables, a las que se obtiene
acceso a través de índices calculados. Las variables contenidas en una matriz, también conocidas
como elementos de la matriz, son todas del mismo tipo, denominado tipo de elemento de la
matriz.

Una matriz tiene un rango que determina el número de índices asociados a cada elemento de la
matriz. El rango de una matriz también se conoce como número de dimensiones de la matriz.
Una matriz con un rango de uno se denomina matriz unidimensional. Una matriz con un rango
mayor que uno se denomina matriz multidimensional. Las matrices multidimensionales de un
determinado tamaño se suelen denominar matrices bidimensionales, tridimensionales, etc.

Cada dimensión de una matriz tiene una longitud asociada, que es un número entero mayor o
igual a cero. Las longitudes de dimensión no forman parte del tipo de matriz, sino que se
establecen cuando se crea una instancia del tipo de matriz en tiempo de ejecución. La longitud de
una dimensión determina el intervalo válido de índices para esa dimensión: para una dimensión
de longitud N, los índices pueden tomar valores de cero a N – 1 inclusive. El número total de
elementos en una matriz es el producto de las longitudes de cada dimensión de la matriz. Si
alguna de las dimensiones de una matriz tiene una longitud cero, se dice que la matriz está vacía.

Los elementos de una matriz pueden ser de cualquier tipo, incluido un tipo de matriz.

Un tipo de matriz se escribe como non-array-type seguido de uno o más especificadores de

rango o rank-specifers:

array-type:
non-array-type rank-specifiers
non-array-type:
type
rank-specifiers:
rank-specifier
rank-specifiers rank-specifier
rank-specifier:
[ dim-separatorsopt ]
dim-separators:
,
dim-separators ,

Un tipo non-array-type es cualquier tipo que no es en sí mismo un tipo array-type.

El rango de un tipo de matriz viene dado por el especificador de rango (rank-specifier) situado en
el extremo izquierdo del tipo de matriz (array-type): así, un especificador de rango indica que la
matriz posee un rango de uno más el número de símbolos "," del especificador de rango.
El tipo de elemento de un tipo de matriz es el tipo resultante de eliminar el especificador de
rango rank-specifier del extremo izquierdo:

 Un tipo de matriz de la forma T[R] es una matriz de rango R y un tipo de elemento que no
sea matriz T.
 Un tipo de matriz de la forma T[R][R1]...[RN] es una matriz de rango R y un tipo de
elemento que no sea matriz T[R1]...[RN].

Lo que sucede es que los especificadores de rango rank-specifiers se leen de izquierda a derecha,
antes del tipo de elemento final que no es matriz. El tipo int[][,,][,] es una matriz
unidimensional que contiene matrices tridimensionales de matrices bidimensionales de tipo int.

En tiempo de ejecución, el valor de un tipo de matriz puede ser null o una referencia a una
instancia de dicho tipo.

Matrices en general

En las matrices de C#, los índices empiezan en cero. Las matrices de C# funcionan de forma
similar a como lo hacen en la mayoría de los lenguajes populares; existen, sin embargo, algunas
diferencias que se deben conocer.

Cuando se declara una matriz, los corchetes ([]) deben ir después del tipo, no después del
identificador. Colocar los corchetes después del identificador no es sintácticamente válido en C#.

int[] table; // not int table[];

Otro detalle es que el tamaño de la matriz no forma parte de su tipo, como ocurre en el lenguaje
C. Esto permite declarar una matriz y asignarle cualquier matriz de objetos int,
independientemente de la longitud de la matriz.

int[] numbers; // declare numbers as an int array of any size

numbers = new int[10]; // numbers is a 10-element array
numbers = new int[20]; // now it's a 20-element array

Declarar matrices

C# admite matrices de una dimensión, matrices multidimensionales (matrices rectangulares) y

matrices de matrices (matrices escalonadas). El siguiente ejemplo muestra cómo declarar
diferentes tipos de matrices:

Matrices unidimensionales:

int[] numbers;

Matrices multidimensionales:
string[,] names;

Matrices de matrices (escalonadas):

byte[][] scores;

La declaración de matrices (como se muestra arriba) no crea realmente las matrices. En C#, las
matrices son objetos (se explica más adelante en este tutorial) cuyas instancias deben crearse.
Los siguientes ejemplos muestran cómo crear matrices:

Matrices unidimensionales:

int[] numbers = new int[5];

Matrices multidimensionales:

string[,] names = new string[5,4];

Matrices de matrices (escalonadas):

byte[][] scores = new byte[5][];

for (int x = 0; x < scores.Length; x++)
{
scores[x] = new byte[4];
}

También se pueden utilizar matrices más grandes. Por ejemplo, se puede utilizar una matriz
rectangular de tres dimensiones:

int[,,] buttons = new int[4,5,3];

Incluso, se pueden combinar matrices rectangulares y escalonadas. Por ejemplo, el siguiente

código declara una matriz unidimensional que contiene matrices tridimensionales de matrices
bidimensionales de tipo int:

int[][,,][,] numbers;

Ejemplo

El siguiente es un programa completo en C# que declara y crea instancias de las matrices

comentadas anteriormente.

// arrays.cs
using System;
class DeclareArraysSample
{
public static void Main()
{
// Single-dimensional array
int[] numbers = new int[5];
 // Multidimensional array
string[,] names = new string[5,4];

// Array-of-arrays (jagged array)

byte[][] scores = new byte[5][];

// Create the jagged array

for (int i = 0; i < scores.Length; i++)
{
scores[i] = new byte[i+3];
}

// Print length of each row

for (int i = 0; i < scores.Length; i++)
{
Console.WriteLine("Length of row {0} is {1}", i,
scores[i].Length);
}
}
}

Resultado

Length of row 0 is 3
Length of row 1 is 4
Length of row 2 is 5
Length of row 3 is 6
Length of row 4 is 7

Inicializar matrices

C# proporciona métodos simples y sencillos para inicializar matrices en el momento de la

declaración encerrando los valores iniciales entre llaves ({}). Los siguientes ejemplos muestran
diferentes modos de inicializar diferentes tipos de matrices.

Nota Si no inicializa una matriz en el momento de la declaración, sus miembros se inicializan

automáticamente con el valor inicial predeterminado para el tipo de matriz. Además, si declara la
matriz como campo de un tipo, se establecerá con el valor predeterminado null cuando cree la
instancia del tipo.

Matrices unidimensionales

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

string[] names = new string[3] {"Matt", "Joanne", "Robert"};

El tamaño de la matriz se puede omitir, como se indica a continuación:

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

string[] names = new string[] {"Matt", "Joanne", "Robert"};

También se puede omitir el operador new si se utiliza un inicializador como el siguiente:

int[] numbers = {1, 2, 3, 4, 5};
string[] names = {"Matt", "Joanne", "Robert"};

Matrices multidimensionales

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

string[,] siblings = new string[2, 2] { {"Mike","Amy"}, {"Mary","Albert"} };

El tamaño de la matriz se puede omitir, como se indica a continuación:

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

string[,] siblings = new string[,] { {"Mike","Amy"}, {"Mary","Albert"} };

También se puede omitir el operador new si se utiliza un inicializador como el siguiente:

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

string[,] siblings = { {"Mike", "Amy"}, {"Mary", "Albert"} };

Matriz escalonada (matriz de matrices)

Las matrices escalonadas se pueden inicializar como en el siguiente ejemplo:

int[][] numbers = new int[2][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

El tamaño de la primera matriz se puede omitir, como se indica a continuación:

int[][] numbers = new int[][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

O bien

int[][] numbers = { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

Observe que no existe sintaxis de inicialización para los elementos de una matriz escalonada.

Acceso a miembros de matrices

El acceso a los miembros de una matriz es sencillo y similar al de los miembros de una matriz de
C o C++. Por ejemplo, el siguiente código crea una matriz denominada numbers y, a
continuación, asigna un 5 al quinto elemento de la matriz:

int[] numbers = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};

numbers[4] = 5;

El siguiente código declara una matriz multidimensional y asigna el valor 5 al miembro ubicado
en [1, 1]:

int[,] numbers = { {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10} };
numbers[1, 1] = 5;
La siguiente es una declaración de una matriz escalonada de una sola dimensión que contiene
dos elementos. El primer elemento es una matriz de dos enteros, mientras que el segundo es una
matriz de tres enteros:

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

La siguiente instrucción asigna 58 al primer elemento de la primera matriz y 667 al segundo

elemento de la segunda matriz:

numbers[0][0] = 58;
numbers[1][1] = 667;

Las matrices son objetos

En C#, las matrices son realmente objetos. System.Array es el tipo base abstracto de todos los
tipos de matrices. Las propiedades y otros miembros de la clase System.Array se pueden utilizar
cuando sea necesario. Un ejemplo de esto sería utilizar la propiedad Length para obtener la
longitud de una matriz. El siguiente código asigna la longitud de la matriz numbers, que es 5, a
una variable denominada LengthOfNumbers:

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

int LengthOfNumbers = numbers.Length;

La clase System.Array proporciona muchos otros métodos y propiedades útiles, como métodos
para ordenar, buscar y copiar matrices.

Usar foreach con matrices

C# dispone de la instrucción foreach. Esta instrucción proporciona un modo simple y limpio de

iterar en los elementos de una matriz. Por ejemplo, el siguiente código crea una matriz
denominada numbers y la recorre mediante la instrucción foreach:

int[] numbers = {4, 5, 6, 1, 2, 3, -2, -1, 0};

foreach (int i in numbers)
{
System.Console.WriteLine(i);
}

Con matrices multidimensionales, se puede utilizar el mismo método para recorrer los elementos,
por ejemplo:

int[,] numbers = new int[3, 2] {{9, 99}, {3, 33}, {5, 55}};
foreach(int i in numbers)
{
Console.Write("{0} ", i);
}
El resultado de este ejemplo es:

9 99 3 33 5 55

Sin embargo, con matrices multidimensionales, utilizar un bucle for anidado proporciona más
control sobre los elementos de la matriz.

Colecciones C#

En muchas aplicaciones se desea poder crear y administrar grupos de objetos relacionados.

Existen dos formas de agrupar objetos: mediante la creación de matrices de objetos y mediante la
creación de colecciones de objetos.

Las matrices son muy útiles para crear y trabajar con un número fijo de objetos fuertemente
tipados.

Las colecciones proporcionan un método más flexible para trabajar con grupos de objetos.

A diferencia de las matrices, el grupo de objetos con el que trabaja puede aumentar y reducirse
dinámicamente a medida que cambian las necesidades de la aplicación. Para algunas colecciones,
puede asignar una clave a cualquier objeto que incluya en la colección para que pueda recuperar
rápidamente el objeto con la clave asignada.

Una colección es una clase, de modo que antes de poder agregar elementos a una nueva
colección, debe declararla.

Si su colección se limita a elementos de solo un tipo de datos, puede utilizar una de las clases en
el espacio de nombres System.Collections.Generic. Una colección genérica cumple la seguridad
de tipos para que ningún otro tipo de datos se pueda agregar a ella. Cuando recupera un elemento
de una colección genérica, no tiene que determinar su tipo de datos ni convertirlo.