Comment puis-je "foreach" au travers d'un tableau à deux dimensions?

Tableaux multidimensionnels ne sont pas énumérable. Juste réitérer la bonne vieille méthode qui consiste à:

for (int i = 0; i < table.GetLength(0); i++)
{
    Console.WriteLine(table[i, 0] + " " + table[i, 1]);
}

Mise à JOUR: j'ai eu un peu de temps sur mes mains, alors ... je suis allé de l'avant et de matérialiser cette idée. Voir ci-dessous pour le code.

---

Ici est un peu fou réponse:

Vous pourrait faire ce que vous êtes à la recherche pour-essentiellement de traiter un tableau à deux dimensions, comme un tableau avec des lignes -- par l'écriture d'une méthode statique (peut-être une méthode d'extension) qui prend un T[,] et renvoie un IEnumerable<T[]>. Cela nécessiterait la copie de chaque "ligne" de la table sous-jacente dans un nouveau tableau, si.

Un peut-être mieux (mais plus impliqués) approche serait d'écrire une classe qui implémente IList<T> comme un wrapper autour d'une seule "ligne" d'un tableau à deux dimensions (vous auriez probablement IsReadOnly de vrai et de juste mettre en œuvre le getter pour le this[int] propriété et probablement Count et GetEnumerator; tout le reste pourrait jeter une NotSupportedException). Ensuite, votre statique/extension de la méthode pourrait retourner un IEnumerable<IList<T>> et de fournir l'exécution différée.

Cette façon, vous pouvez écrire du code un peu comme ce que vous avez:

foreach (IList<string> row in table.GetRows()) //or something
{
    Console.WriteLine(row[0] + " " + row[1]);
}

Juste une pensée.

---

Mise en œuvre suggestion:

public static class ArrayTableHelper {
public static IEnumerable<IList<T>> GetRows<T>(this T[,] table) {
for (int i = 0; i < table.GetLength(0); ++i)
yield return new ArrayTableRow<T>(table, i);
}
private class ArrayTableRow<T> : IList<T> {
private readonly T[,] _table;
private readonly int _count;
private readonly int _rowIndex;
public ArrayTableRow(T[,] table, int rowIndex) {
if (table == null)
throw new ArgumentNullException("table");
if (rowIndex < 0 || rowIndex >= table.GetLength(0))
throw new ArgumentOutOfRangeException("rowIndex");
_table = table;
_count = _table.GetLength(1);
_rowIndex = rowIndex;
}
//I didn't implement the setter below,
//but you easily COULD (and then set IsReadOnly to false?)
public T this[int index] {
get { return _table[_rowIndex, index]; }
set { throw new NotImplementedException(); }
}
public int Count {
get { return _count; }
}
bool ICollection<T>.IsReadOnly {
get { return true; }
}
public IEnumerator<T> GetEnumerator() {
for (int i = 0; i < _count; ++i)
yield return this[i];
}
//omitted remaining IList<T> members for brevity;
//you actually could implement IndexOf, Contains, etc.
//quite easily, though
}
}

...maintenant je pense que je devrais donner StackOverflow une pause pour le reste de la journée 😉

string[][] table = { ... };

Ici est une simple extension de la méthode qui retourne chaque ligne comme un IEnumerable<T>. Ceci a l'avantage de ne pas utiliser toute la mémoire supplémentaire:

public static class Array2dExt
{
public static IEnumerable<IEnumerable<T>> Rows<T>(this T[,] array)
{
for (int r = array.GetLowerBound(0); r <= array.GetUpperBound(0); ++r)
yield return row(array, r);
}
static IEnumerable<T> row<T>(T[,] array, int r)
{
for (int c = array.GetLowerBound(1); c <= array.GetUpperBound(1); ++c)
yield return array[r, c];
}
}

Exemple d'utilisation:

static void Main()
{
string[,] siblings = { { "Mike", "Amy" }, { "Mary", "Albert" }, {"Fred", "Harry"} };
foreach (var row in siblings.Rows())
Console.WriteLine("{" + string.Join(", ", row) + "}");
}

Se rappeler qu'un tableau multidimensionnel est comme un tableau. Vous n'avez pas de x et un y de l'élément pour chaque entrée, vous avez une chaîne (par exemple) table[1,2].

Ainsi, chaque entrée est une chaîne de caractères (dans votre exemple), c'est juste une entrée à un x/y de la valeur. Donc, pour obtenir les deux entrées à table[1, x], vous feriez un imbriqués pour la boucle. Quelque chose comme ce qui suit (pas testé, mais il devrait être proche)

for (int x = 0; x < table.Length; x++)
{
for (int y = 0; y < table.Length; y += 2)
{
Console.WriteLine("{0} {1}", table[x, y], table[x, y + 1]);
}
}

Je ne suis pas un grand fan de cette méthode en raison de l'utilisation de la mémoire impliqués, mais si vous utilisez les tableaux qu'il produit, il n'est pas un déchet.

public static void ForEachRow<T>(this T[,] list, Action<int, T[]> action)
{
var len = list.GetLength(0);
var sub = list.GetLength(1);
T[] e;
int i, j;
for (i = 0; i < len; i++)
{
e = new T[sub];
for (j = 0; j < sub; j++)
{
e[j] = list[i, j];
}
action(i, e);
}
}

Mise en œuvre:

var list = new[,]{0x0, 0x1, 0x2, 0x4, 0x8};
list.ForEachRow((i, row) =>
{
for (var j = 0; j < row.Length; j++)
{
Console.WriteLine("[{0},{1}]: {2}", i, j, row[j]);
}
});

L'autre solution que j'ai trouvé est moins gourmande en mémoire, mais l'utilisation de plus de CPU, en particulier lorsque les dimensions des tableaux entrées sont plus grandes.

public static void ForEachRow<T>(this T[,] list, Action<int, IEnumerable<T>> action)
{
var len = list.GetLength(0);
var sub = list.GetLength(1);
int i, j;
IEnumerable<T> e;
for (i = 0; i < len; i++)
{
e = Enumerable.Empty<T>();
for (j = 0; j < sub; j++)
{
e = e.Concat(AsEnumerable(list[i, j]));
}
action(i, e);
}
}
private static IEnumerable<T> AsEnumerable<T>(T add)
{
yield return add;
}

Mise en œuvre:

var list = new[,]{0x0, 0x1, 0x2, 0x4, 0x8};
list.ForEachRow((i, row) =>
{
var j = 0;
forrach (var o in row)
{
Console.WriteLine("[{0},{1}]: {2}", i, j, o);
++j;
}
});

Comme un ensemble, je trouve la première option pour être plus intuitive, surtout si vous souhaitez accéder à la table produite par son indexation.

À la fin de la journée, c'est tous simplement des bonbons pour les yeux, ni les méthodes devrait vraiment être utilisé en faveur de l'accès direct de la source matrice;

for (var i = 0; i < list.GetLength(0); i++)
{
foreach (var j = 0; j < list.GetLength(1); j++)
{
Console.WriteLine("[{0},{1}]: {2}", i, j, list[i, j]);
}
}