¿Cómo recorre una matriz multidimensional?

Question

foreach (String s in arrayOfMessages) 
{ 
    System.Console.WriteLine(s); 
} 

string[,] arrayOfMessages se está pasando como un parámetro.

Quiero ser capaz de determinar qué cadenas son de arrayOfMessages[0,i] y arrayOfMessages[n,i], donde n es el índice final de la matriz.

Answer 1

Sólo tiene que utilizar dos for bucles anidados. Para obtener los tamaños de las dimensiones, puede utilizar GetLength():

for (int i = 0; i < arrayOfMessages.GetLength(0); i++) 
{ 
    for (int j = 0; j < arrayOfMessages.GetLength(1); j++) 
    { 
     string s = arrayOfMessages[i, j]; 
     Console.WriteLine(s); 
    } 
} 

Esto supone que en realidad tienen string[,]. En .Net también es posible tener matrices multidimensionales que no están indexadas desde 0. En ese caso, deben representarse como Array en C# y necesitarías usar GetLowerBound() y GetUpperBound() para obtener los límites para cada dimensión.

Answer 2

No utilice foreach - utilice ciclos anidados for, uno para cada dimensión de la matriz.

Puede obtener el número de elementos en cada dimensión con el método GetLength.

Consulte Multidimensional Arrays (C# Programming Guide) en MSDN.

Answer 3

Con un bucle anidado para:

for (int row = 0; row < arrayOfMessages.GetLength(0); row++) 
{ 
    for (int col = 0; col < arrayOfMessages.GetLength(1); col++) 
    { 
     string message = arrayOfMessages[row,col]; 
     // use the message 
    }  
} 

Answer 4

Algo como esto funcionaría:

int length0 = arrayOfMessages.GetUpperBound(0) + 1; 
int length1 = arrayOfMessages.GetUpperBound(1) + 1; 

for(int i=0; i<length1; i++) { string msg = arrayOfMessages[0, i]; ... } 
for(int i=0; i<length1; i++) { string msg = arrayOfMessages[length0-1, i]; ... } 

Answer 5

Usted puede utilizar el código siguiente para ejecutar matrices multidimensionales.

foreach (String s in arrayOfMessages) 
{ 
    System.Console.WriteLine("{0}",s); 
} 

Answer 6

Parece que has encontrado una respuesta adecuada para su problema, pero ya que el título le pide una matriz multidimensional (que lee como 2 o más), y este es el primer resultado de búsqueda me dieron cuando la búsqueda de eso, voy a poner mi solución: ejemplo

public static class MultidimensionalArrayExtensions 
{ 
    /// <summary> 
    /// Projects each element of a sequence into a new form by incorporating the element's index. 
    /// </summary> 
    /// <typeparam name="T">The type of the elements of the array.</typeparam> 
    /// <param name="array">A sequence of values to invoke the action on.</param> 
    /// <param name="action">An action to apply to each source element; the second parameter of the function represents the index of the source element.</param> 
    public static void ForEach<T>(this Array array, Action<T, int[]> action) 
    { 
     var dimensionSizes = Enumerable.Range(0, array.Rank).Select(i => array.GetLength(i)).ToArray(); 
     ArrayForEach(dimensionSizes, action, new int[] { }, array); 
    } 
    private static void ArrayForEach<T>(int[] dimensionSizes, Action<T, int[]> action, int[] externalCoordinates, Array masterArray) 
    { 
     if (dimensionSizes.Length == 1) 
      for (int i = 0; i < dimensionSizes[0]; i++) 
      { 
       var globalCoordinates = externalCoordinates.Concat(new[] { i }).ToArray(); 
       var value = (T)masterArray.GetValue(globalCoordinates); 
       action(value, globalCoordinates); 
      } 
     else 
      for (int i = 0; i < dimensionSizes[0]; i++) 
       ArrayForEach(dimensionSizes.Skip(1).ToArray(), action, externalCoordinates.Concat(new[] { i }).ToArray(), masterArray); 
    } 

    public static void PopulateArray<T>(this Array array, Func<int[], T> calculateElement) 
    { 
     array.ForEach<T>((element, indexArray) => array.SetValue(calculateElement(indexArray), indexArray)); 
    } 
} 

Uso:

var foo = new string[,] { { "a", "b" }, { "c", "d" } }; 
foo.ForEach<string>((value, coords) => Console.WriteLine("(" + String.Join(", ", coords) + $")={value}")); 
// outputs: 
// (0, 0)=a 
// (0, 1)=b 
// (1, 0)=c 
// (1, 1)=d 

// Gives a 10d array where each element equals the sum of its coordinates: 
var bar = new int[4, 4, 4, 5, 6, 5, 4, 4, 4, 5]; 
bar.PopulateArray(coords => coords.Sum()); 

idea general es recursivo a través de las dimensiones . Estoy seguro de que las funciones no ganarán premios de eficiencia, pero funciona como un inicializador único para mi celosía y viene con un ForEach bastante bueno que expone los valores y los índices. La desventaja principal que no he resuelto es lograr que reconozca automáticamente T de la matriz, por lo que se requiere cierta precaución cuando se trata del tipo de seguridad.