Как вы проходите через многомерный массив?

Ответ 1

Просто используйте две вложенные петли for. Чтобы получить размеры размеров, вы можете использовать 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);
    }
}

Предполагается, что у вас есть string[,]. В .Net также возможно иметь многомерные массивы, которые не индексируются с 0. В этом случае они должны быть представлены как Array в С#, и вам нужно будет использовать GetLowerBound() и GetUpperBound() получить границы для каждого измерения.

Ответ 2

С вложенным циклом цикла:

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

Ответ 3

Не используйте foreach - используйте вложенные петли for, по одному для каждого измерения массива.

Вы можете получить количество элементов в каждом измерении с помощью метода GetLength.

См. Многомерные массивы (Руководство по программированию на С#) в MSDN.

Ответ 4

Что-то вроде этого будет работать:

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]; ... }

Ответ 5

Вы можете использовать приведенный ниже код для запуска многомерных массивов.

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

Ответ 6

Похоже, вы нашли ответ, подходящий для вашей проблемы, но поскольку название запрашивает многомерный массив (который я читаю как 2 или более), и это первый результат поиска, который я получил при поиске, добавлю свое решение:

public static class MultidimensionalArrayExtensions
{
    /// <summary>
    /// Projects each element of a sequence into a new form by incorporating the element 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));
    }
}

Пример использования:

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

Общая идея состоит в том, чтобы пропустить измерения. Я уверен, что функции не выиграют награды за эффективность, но он работает как одноразовый инициализатор для моей решетки и поставляется с достаточно хорошим ForEach, который предоставляет значения и индексы. Основной недостаток, который я не решил, заключается в том, что он автоматически распознает T из массива, поэтому необходимо соблюдать осторожность, когда дело касается безопасности типа.