Come si esegue il ciclo di un array multidimensionale?

Question

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

string[,] arrayOfMessages viene passato come parametro.

Voglio essere in grado di determinare quali stringhe sono da arrayOfMessages[0,i] e arrayOfMessages[n,i], dove n è l'indice finale della matrice.

Answer 1

sufficiente utilizzare due annidati for loop. Per ottenere le dimensioni delle dimensioni, è possibile utilizzare 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); 
    } 
} 

Ciò presuppone che effettivamente hanno string[,]. In .Net è anche possibile avere array multidimensionali che non sono indicizzati da 0. In tal caso, devono essere rappresentati come Array in C# e sarà necessario utilizzare GetLowerBound() e GetUpperBound() per ottenere i limiti per ciascuna dimensione.

Answer 2

Non utilizzare foreach - utilizzare i cicli nidificati for, uno per ciascuna dimensione della matrice.

È possibile ottenere il numero di elementi in ogni dimensione con il metodo GetLength.

Vedere Multidimensional Arrays (C# Programming Guide) su MSDN.

Answer 3

Con un ciclo for nidificato:

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

Qualcosa di simile potrebbe funzionare:

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

È possibile utilizzare il codice qui sotto per eseguire gli array multidimensionali.

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

Answer 6

Sembra che hai trovato una risposta adatta per il vostro problema, ma dal momento che il titolo richiede un array multidimensionale (che ho letto come 2 o più), e questo è il primo risultato della ricerca ho avuto quando alla ricerca di quella, aggiungerò la mia soluzione: esempio

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)); 
    } 
} 

Usage:

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 generale è quella di ricorsione verso il basso attraverso le dimensioni . Sono sicuro che le funzioni non vinceranno i premi di efficienza, ma funziona come inizializzatore unico per il mio reticolo e viene fornito con un ForEach abbastanza carino che espone valori e indici. Lo svantaggio principale che non ho risolto è quello di riconoscere automaticamente T dalla matrice, quindi è necessario prestare attenzione quando si parla di sicurezza del tipo.