繰り返し文

【C#】foreachで多次元配列を効率的に巡回しインデックスを扱う方法

2025-04-30更新日: 2025-04-30

結論、多次元配列をC#のforeachで回すと全要素が一次元に展開され順番に取得されるため、行列などの座標情報は保持されない。

行ごと列ごとに処理したい、あるいはインデックスが必要ならforとGetLengthを組み合わせる方法が確実です。

目次から探す

多次元配列とは
foreachと多次元配列の基礎
行列データをforeachで処理するパターン
インデックス情報が必要なケース
拡張メソッドでforeachにインデックスを渡す設計
- IEnumerable<(int row, int col, T value)>の実装
- パフォーマンステストと考察
foreachとforの比較検証
例外処理と安全な列挙
- null配列の取り扱い
- 要素更新を伴う場合の注意点
3次元以上の配列への拡張
マルチスレッド環境での多次元配列列挙
- Parallel.ForとParallel.ForEachの選択
- データ競合回避の方法
メモリとパフォーマンス最適化
典型的なユースケース別サンプル
LINQでの多次元配列操作
罠とよくあるミス
まとめ

多次元配列とは

C#における多次元配列は、複数の次元を持つ配列のことを指します。

一般的に、1次元配列は単純なリストのような構造ですが、多次元配列は行列や立体的なデータ構造を表現するのに適しています。

たとえば、2次元配列は表形式のデータ、3次元配列は立体的な格子データなどを扱う際に使われます。

多次元配列は、複数のインデックスを使って要素にアクセスできるため、データの位置を直感的に表現しやすい特徴があります。

ただし、C#では多次元配列の他に「ジャグ配列」と呼ばれる配列の配列も存在し、用途や性能面で使い分けが必要です。

多次元配列の宣言例

C#で多次元配列を宣言する際は、カンマで区切った次元数を指定します。

以下に2次元配列と3次元配列の宣言例を示します。

using System;
class Program
{
    static void Main()
    {
        // 2次元配列の宣言と初期化(3行4列)
        int[,] matrix = new int[3, 4]
        {
            { 1, 2, 3, 4 },
            { 5, 6, 7, 8 },
            { 9, 10, 11, 12 }
        };
        // 3次元配列の宣言と初期化(2×2×3)
        int[,,] cube = new int[2, 2, 3]
        {
            {
                { 1, 2, 3 },
                { 4, 5, 6 }
            },
            {
                { 7, 8, 9 },
                { 10, 11, 12 }
            }
        };
        // 2次元配列の要素を表示
        Console.WriteLine("2次元配列の要素:");
        for (int i = 0; i < matrix.GetLength(0); i++)
        {
            for (int j = 0; j < matrix.GetLength(1); j++)
            {
                Console.Write(matrix[i, j] + " ");
            }
            Console.WriteLine();
        }
        // 3次元配列の要素を表示
        Console.WriteLine("\n3次元配列の要素:");
        for (int i = 0; i < cube.GetLength(0); i++)
        {
            for (int j = 0; j < cube.GetLength(1); j++)
            {
                for (int k = 0; k < cube.GetLength(2); k++)
                {
                    Console.Write(cube[i, j, k] + " ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
    }
}

この例では、int[,]が2次元配列、int[,,]が3次元配列を表しています。

GetLength(dim)メソッドを使うことで、指定した次元の長さを取得できます。

多次元配列は固定サイズで、宣言時にサイズを指定する必要があります。

2次元配列とジャグ配列の違い

C#には多次元配列の他に「ジャグ配列(Jagged Array)」と呼ばれる配列の配列があります。

ジャグ配列は、各行の長さが異なることが許されるため、可変長の2次元配列として使われることが多いです。

特徴	2次元配列 `(int[,])`	ジャグ配列 `(int[][])`
メモリ構造	連続したメモリ領域	配列の配列で、各配列は別々の領域
各行の長さ	固定	可変
宣言例	`int[,] matrix = new int[3,4];`	`int[][] jagged = new int[3][];`
要素アクセス	`matrix[i, j]`	`jagged[i][j]`
パフォーマンス	高い(連続メモリでキャッシュ効率良)	やや低い(ポインタ間接参照あり)
柔軟性	低い(全行同じ長さ)	高い(行ごとに長さが異なる)

ジャグ配列は、例えば行ごとに異なる数の要素を持つデータを扱う場合に便利です。

以下にジャグ配列の宣言例を示します。

using System;
class Program
{
    static void Main()
    {
        // ジャグ配列の宣言と初期化
        int[][] jagged = new int[3][];
        jagged[0] = new int[] { 1, 2, 3 };
        jagged[1] = new int[] { 4, 5 };
        jagged[2] = new int[] { 6, 7, 8, 9 };
        // ジャグ配列の要素を表示
        for (int i = 0; i < jagged.Length; i++)
        {
            Console.Write("( ");
            for (int j = 0; j < jagged[i].Length; j++)
            {
                Console.Write(jagged[i][j] + " ");
            }
            Console.WriteLine(")");
        }
    }
}

( 1 2 3 )
( 4 5 )
( 6 7 8 9 )

このように、ジャグ配列は行ごとに異なる長さの配列を持てるため、柔軟なデータ構造を表現できます。

メモリ配置とデータ構造

多次元配列とジャグ配列はメモリ上の配置が異なるため、パフォーマンスやアクセス方法に影響を与えます。

多次元配列のメモリ配置

C#の多次元配列は、CLR(Common Language Runtime)によって連続したメモリ領域に格納されます。

たとえば、2次元配列int[3,4]は3行4列の要素が連続してメモリに並びます。

これは行優先(Row-major)で格納されており、最初の行の全要素が連続し、その次に2行目の全要素が続く形です。

この連続配置により、CPUのキャッシュ効率が良くなり、ループ処理などで高速にアクセスできます。

ただし、配列のサイズは固定で、途中でサイズ変更はできません。

ジャグ配列のメモリ配置

ジャグ配列は配列の配列であるため、各行は独立した配列オブジェクトとしてヒープ上に存在します。

つまり、int[][]の最初の配列は3つの参照を持ち、それぞれが別々の配列を指しています。

この構造は柔軟性が高い反面、メモリアクセス時に間接参照が発生し、キャッシュ効率が低下する可能性があります。

特に大量のデータを高速に処理する場合は注意が必要です。

データ構造の違いまとめ

配列の種類	メモリ配置の特徴	アクセスコスト	サイズ変更の可否
多次元配列	連続したメモリ領域(行優先)	低い(高速アクセス可能)	不可
ジャグ配列	配列の配列で各行は独立したメモリ領域	高い(間接参照が発生)	可(各行の長さは自由)

このように、用途に応じて多次元配列とジャグ配列を使い分けることが重要です。

たとえば、固定サイズの行列演算や画像処理などでは多次元配列が適しており、可変長のデータを扱う場合はジャグ配列が便利です。

foreachと多次元配列の基礎

foreachが生成する列挙子の仕組み

C#のforeach文は、対象のコレクションや配列に対して列挙子(Enumerator)を生成し、要素を順に取り出して処理します。

多次元配列に対してforeachを使う場合も同様で、内部的には配列の全要素を1次元的に列挙する列挙子が生成されます。

多次元配列はSystem.Arrayを継承しており、IEnumerableインターフェースを実装しています。

foreachはこのIEnumerableのGetEnumerator()メソッドを呼び出し、返された列挙子のMoveNext()とCurrentプロパティを使って要素を順に取得します。

この列挙子は多次元配列の全要素を「平坦化」して1次元のシーケンスとして扱うため、foreachで取り出す要素は多次元のインデックス情報を持ちません。

つまり、foreachで得られるのは単なる値の列であり、どの行・列に属するかは分からない状態です。

以下のコードは2次元配列に対してforeachを使った例です。

using System;
class Program
{
    static void Main()
    {
        int[,] matrix = {
            { 10, 20, 30 },
            { 40, 50, 60 }
        };
        foreach (var value in matrix)
        {
            Console.Write(value + " ");
        }
    }
}

10 20 30 40 50 60

このように、foreachは2次元配列の要素を1次元的に列挙します。

列挙子は配列の内部構造に依存しており、要素の順序は配列のメモリ配置に基づいています。

平坦化される要素列の順序

多次元配列の要素がforeachで平坦化される際の順序は、C#の配列が行優先(Row-major)で格納されていることに由来します。

つまり、最初の行の全要素が先に列挙され、その後に2行目、3行目…と続きます。

例えば、3行4列の2次元配列があった場合、foreachは以下の順序で要素を取り出します。

行	列0	列1	列2	列3
0	0	1	2	3
1	4	5	6	7
2	8	9	10	11

foreachでの列挙順は、0,1,2,3,4,5,6,7,8,9,10,11の順番になります。

この順序は、配列のGetEnumerator()が内部的にArray.InternalEnumeratorを使い、配列の先頭から末尾まで連続的にアクセスするためです。

配列のストライドとforeachの関係

配列の「ストライド」とは、次元ごとに要素間のメモリ上の距離を指します。

多次元配列は連続したメモリ領域に格納されているため、ストライドは次元のサイズに基づいて計算されます。

例えば、2次元配列int[3,4]の場合、1行あたり4つの要素が連続しているため、行のストライドは4です。

つまり、行を1つ進むとメモリ上で4つ分の要素を飛び越えます。

foreachはこのストライドを意識せず、配列の先頭から末尾まで連続的に要素を取り出します。

これは、foreachが配列の内部的な1次元的なメモリブロックをそのまま列挙しているためです。

ストライドの概念は、forループで多次元配列のインデックスを使ってアクセスする際に重要になります。

例えば、2次元配列の要素matrix[i, j]は、内部的にはbaseAddress + i * strideRow + jの位置に格納されています。

以下のコードは、2次元配列のストライドを意識したアクセス例です。

using System;
class Program
{
    static void Main()
    {
        int[,] matrix = {
            { 1, 2, 3 },
            { 4, 5, 6 }
        };
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        Console.WriteLine("行ごとの要素表示:");
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                Console.Write(matrix[i, j] + " ");
            }
            Console.WriteLine();
        }
    }
}

行ごとの要素表示:
1 2 3
4 5 6

このように、forループで行と列のインデックスを使うことで、ストライドを意識したアクセスが可能です。

一方、foreachはストライドを隠蔽し、単純に全要素を連続的に列挙します。

この違いを理解することで、foreachで多次元配列を扱う際の挙動や、インデックス情報が必要な場合の対処法が見えてきます。

行列データをforeachで処理するパターン

すべての要素に対する一括操作

多次元配列のすべての要素に対して同じ処理を行う場合、foreachはシンプルで読みやすいコードを実現します。

例えば、行列の全要素に一定の値を加算したり、正規化処理を行ったりするケースです。

ただし、foreachは読み取り専用の列挙子を返すため、要素の直接書き換えはできません。

要素の更新が必要な場合は、forループを使うか、別の配列に結果を格納する方法が一般的です。

要素値の加算・正規化など

以下の例は、2次元配列のすべての要素に10を加算し、新しい配列に結果を格納するコードです。

using System;
class Program
{
    static void Main()
    {
        int[,] matrix = {
            { 1, 2, 3 },
            { 4, 5, 6 }
        };
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        // 新しい配列を用意
        int[,] result = new int[rows, cols];
        int index = 0;
        foreach (var value in matrix)
        {
            // 1次元的なindexから2次元の行列インデックスを計算
            int row = index / cols;
            int col = index % cols;
            // 10を加算して新しい配列に格納
            result[row, col] = value + 10;
            index++;
        }
        // 結果を表示
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                Console.Write(result[i, j] + " ");
            }
            Console.WriteLine();
        }
    }
}

11 12 13
14 15 16

この例では、foreachで平坦化された要素を順に取り出し、インデックス計算で元の行列の位置を特定しています。

これにより、要素の更新は新しい配列に対して行っています。

次に、正規化の例を示します。

正規化とは、行列の要素を最大値で割って0から1の範囲に収める処理です。

using System;
class Program
{
    static void Main()
    {
        double[,] matrix = {
            { 2.0, 4.0, 6.0 },
            { 8.0, 10.0, 12.0 }
        };
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        // 最大値を求める
        double max = double.MinValue;
        foreach (var value in matrix)
        {
            if (value > max) max = value;
        }
        // 正規化結果を格納する配列
        double[,] normalized = new double[rows, cols];
        int index = 0;
        foreach (var value in matrix)
        {
            int row = index / cols;
            int col = index % cols;
            normalized[row, col] = value / max;
            index++;
        }
        // 結果を表示
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                Console.Write($"{normalized[i, j]:F2} ");
            }
            Console.WriteLine();
        }
    }
}

0.17 0.33 0.50
0.67 0.83 1.00

このように、foreachで全要素を列挙しながら計算を行い、別の配列に結果を格納するパターンは多くの場面で使えます。

条件に応じたフィルタリング

多次元配列の要素を条件に基づいて抽出したい場合、foreachと条件分岐を組み合わせる方法が基本です。

例えば、ある閾値以上の要素だけを取り出すケースです。

ただし、foreachは平坦化された要素列を返すため、元の行列の行・列の情報は持ちません。

行列の位置情報が必要な場合は、インデックス計算を併用するか、forループを使うことが多いです。

LINQとの組み合わせ

LINQを使うと、多次元配列の要素を簡潔にフィルタリングできます。

Cast<T>()メソッドで配列をIEnumerable<T>に変換し、WhereやSelectを使って条件に合う要素を抽出します。

以下は、2次元配列の要素のうち5以上の値だけを抽出して表示する例です。

using System;
using System.Linq;
class Program
{
    static void Main()
    {
        int[,] matrix = {
            { 1, 3, 5 },
            { 7, 2, 8 }
        };
        // Cast<int>()で平坦化し、5以上の要素を抽出
        var filtered = matrix.Cast<int>().Where(x => x >= 5);
        Console.WriteLine("5以上の要素:");
        foreach (var value in filtered)
        {
            Console.Write(value + " ");
        }
    }
}

5 7 8

この方法はコードがシンプルで読みやすく、条件に応じた抽出が容易です。

ただし、元の行列の行・列の位置情報は失われるため、必要な場合は別途インデックス計算が必要です。

パフォーマンス測定のポイント

foreachを使った多次元配列の処理は簡潔ですが、パフォーマンス面で注意すべき点があります。

特に大量データを扱う場合は、処理速度やメモリ効率を意識する必要があります。

インデックス計算のコスト

foreachで平坦化された要素に対して行・列のインデックスを計算する場合、割り算や剰余演算が頻繁に発生します。

これがボトルネックになることがあるため、可能ならforループで直接インデックスを使うほうが高速です。

配列の書き換え

foreachは読み取り専用の列挙子を返すため、要素の直接更新はできません。

更新が必要な場合はforループを使うか、新しい配列に結果を格納する必要があります。

これによりメモリ使用量が増えることがあります。

LINQのオーバーヘッド

LINQを使うとコードが簡潔になりますが、内部で列挙子やデリゲートが生成されるため、オーバーヘッドが発生します。

パフォーマンスが重要な場面では、LINQの使用を控え、ループ処理を明示的に書くほうが良い場合があります。

キャッシュ効率

多次元配列は連続したメモリに格納されているため、forループで行優先にアクセスするとキャッシュ効率が良くなります。

foreachはこの点では問題ありませんが、ジャグ配列の場合はアクセスパターンに注意が必要です。

パフォーマンスを測定する際は、System.Diagnostics.Stopwatchを使って処理時間を計測し、foreachとforの違いやLINQの影響を比較すると良いでしょう。

以下は簡単なパフォーマンス計測の例です。

using System;
using System.Diagnostics;
using System.Linq;
class Program
{
    static void Main()
    {
        int size = 1000;
        int[,] matrix = new int[size, size];
        Random rand = new Random();
        // 配列をランダムで初期化
        for (int i = 0; i < size; i++)
            for (int j = 0; j < size; j++)
                matrix[i, j] = rand.Next(1000);
        Stopwatch sw = new Stopwatch();
        // foreachで合計を計算
        sw.Start();
        long sumForeach = 0;
        foreach (var val in matrix)
        {
            sumForeach += val;
        }
        sw.Stop();
        Console.WriteLine($"foreach合計: {sumForeach}, 時間: {sw.ElapsedMilliseconds} ms");
        // forで合計を計算
        sw.Restart();
        long sumFor = 0;
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        for (int i = 0; i < rows; i++)
            for (int j = 0; j < cols; j++)
                sumFor += matrix[i, j];
        sw.Stop();
        Console.WriteLine($"for合計: {sumFor}, 時間: {sw.ElapsedMilliseconds} ms");
        // LINQで合計を計算
        sw.Restart();
        long sumLinq = matrix.Cast<int>().Sum(x => (long)x);
        sw.Stop();
        Console.WriteLine($"LINQ合計: {sumLinq}, 時間: {sw.ElapsedMilliseconds} ms");
    }
}

foreach合計: 499601626, 時間: 1 ms
for合計: 499601626, 時間: 1 ms
LINQ合計: 499601626, 時間: 62 ms

この結果は環境によって異なりますが、一般的にforループが最も高速で、foreachがやや遅く、LINQは最も遅くなる傾向があります。

用途に応じて使い分けることが重要です。

インデックス情報が必要なケース

多次元配列をforeachで処理するとき、要素の値は取得できますが、行や列のインデックス情報は得られません。

行や列ごとの処理や、座標情報を使った操作が必要な場合は、インデックスを明示的に扱う方法が求められます。

行ごとの処理

行ごとの処理では、各行の要素をまとめて扱い、行番号に基づく計算や集約を行います。

foreachだけでは行番号が分からないため、forループやインデックス計算を併用することが多いです。

行番号に基づく累積計算

例えば、2次元配列の各行の合計値を計算し、行番号とともに表示する例です。

using System;
class Program
{
    static void Main()
    {
        int[,] matrix = {
            { 1, 2, 3 },
            { 4, 5, 6 },
            { 7, 8, 9 }
        };
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        for (int i = 0; i < rows; i++)
        {
            int rowSum = 0;
            for (int j = 0; j < cols; j++)
            {
                rowSum += matrix[i, j];
            }
            Console.WriteLine($"行 {i} の合計: {rowSum}");
        }
    }
}

行 0 の合計: 6
行 1 の合計: 15
行 2 の合計: 24

このように、forループで行番号を明示的に扱うことで、行ごとの累積計算が可能です。

foreachだけで行番号を取得することはできません。

列ごとの処理

列ごとの処理では、各列の要素をまとめて扱い、最大値や平均値などを計算します。

行ごとの処理と同様に、インデックスを使って列を指定する必要があります。

列最大値・平均値の算出

以下は、2次元配列の各列の最大値と平均値を計算して表示する例です。

using System;
class Program
{
    static void Main()
    {
        int[,] matrix = {
            { 3, 5, 7 },
            { 2, 8, 6 },
            { 9, 1, 4 }
        };
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        for (int j = 0; j < cols; j++)
        {
            int max = int.MinValue;
            int sum = 0;
            for (int i = 0; i < rows; i++)
            {
                int val = matrix[i, j];
                if (val > max) max = val;
                sum += val;
            }
            double avg = (double)sum / rows;
            Console.WriteLine($"列 {j} の最大値: {max}, 平均値: {avg:F2}");
        }
    }
}

列 0 の最大値: 9, 平均値: 4.67
列 1 の最大値: 8, 平均値: 4.67
列 2 の最大値: 7, 平均値: 5.67

列ごとの処理もforループで列インデックスを明示的に扱うことで実現できます。

座標込みで要素を列挙する代替アプローチ

foreachで多次元配列を列挙するとインデックス情報が得られないため、座標(行・列)を含めて要素を扱いたい場合は別の方法を使います。

ここではforループとのハイブリッドや、拡張メソッドを使った方法を紹介します。

forループとのハイブリッド

最もシンプルな方法は、forループで行と列のインデックスを使いながら要素を列挙することです。

これにより、座標情報を明示的に扱えます。

using System;
class Program
{
    static void Main()
    {
        int[,] matrix = {
            { 10, 20 },
            { 30, 40 }
        };
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                Console.WriteLine($"座標 ({i}, {j}) の値: {matrix[i, j]}");
            }
        }
    }
}

座標 (0, 0) の値: 10
座標 (0, 1) の値: 20
座標 (1, 0) の値: 30
座標 (1, 1) の値: 40

この方法は最も直感的で、座標情報を使った処理に適しています。

Tupleや匿名型でインデックスを返す拡張メソッド

foreachで座標情報を扱いたい場合、拡張メソッドを作成して、要素とインデックスを同時に返す方法があります。

これにより、foreachのシンプルさを保ちつつ、座標情報を取得できます。

以下は、2次元配列に対して行・列のインデックスと値を返す拡張メソッドの例です。

using System;
using System.Collections.Generic;
static class ArrayExtensions
{
    public static IEnumerable<(int Row, int Col, T Value)> WithIndices<T>(this T[,] array)
    {
        int rows = array.GetLength(0);
        int cols = array.GetLength(1);
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                yield return (i, j, array[i, j]);
            }
        }
    }
}
class Program
{
    static void Main()
    {
        int[,] matrix = {
            { 100, 200 },
            { 300, 400 }
        };
        foreach (var (row, col, value) in matrix.WithIndices())
        {
            Console.WriteLine($"座標 ({row}, {col}) の値: {value}");
        }
    }
}

座標 (0, 0) の値: 100
座標 (0, 1) の値: 200
座標 (1, 0) の値: 300
座標 (1, 1) の値: 400

この拡張メソッドは、foreachの使いやすさを維持しつつ、行・列のインデックスを同時に扱えるため、座標情報が必要な処理に便利です。

匿名型やTupleを使うことで、戻り値の型を簡潔に表現できます。

このように、インデックス情報が必要な場合はforループを使うか、拡張メソッドで座標付きの列挙を実装する方法が効果的です。

拡張メソッドでforeachにインデックスを渡す設計

C#のforeach文は通常、配列やコレクションの要素だけを列挙しますが、多次元配列の要素に加えて行・列のインデックス情報も同時に取得したい場合があります。

これを実現するために、拡張メソッドを使ってIEnumerable<(int row, int col, T value)>を返す設計が有効です。

こうすることで、foreachのシンプルさを保ちつつ、インデックス付きで要素を扱えます。

IEnumerable<(int row, int col, T value)>の実装

拡張メソッドとして、多次元配列の全要素を行・列のインデックスとともに列挙するメソッドを実装します。

戻り値はタプル(int row, int col, T value)の列挙可能なシーケンスです。

このメソッドは、2次元配列の行数と列数を取得し、二重のforループで全要素を走査しながら、yield returnでタプルを返します。

これにより、呼び出し側はforeachでインデックスと値を同時に受け取れます。

サンプルコード概要

以下は、2次元配列に対する拡張メソッドWithIndicesの実装例と使用例です。

using System;
using System.Collections.Generic;
static class ArrayExtensions
{
    // 2次元配列に対して行・列・値を返す拡張メソッド
    public static IEnumerable<(int row, int col, T value)> WithIndices<T>(this T[,] array)
    {
        int rows = array.GetLength(0);
        int cols = array.GetLength(1);
        for (int row = 0; row < rows; row++)
        {
            for (int col = 0; col < cols; col++)
            {
                yield return (row, col, array[row, col]);
            }
        }
    }
}
class Program
{
    static void Main()
    {
        int[,] matrix = {
            { 10, 20, 30 },
            { 40, 50, 60 }
        };
        // 拡張メソッドを使ってインデックス付きで列挙
        foreach (var (row, col, value) in matrix.WithIndices())
        {
            Console.WriteLine($"座標 ({row}, {col}) の値: {value}");
        }
    }
}

座標 (0, 0) の値: 10
座標 (0, 1) の値: 20
座標 (0, 2) の値: 30
座標 (1, 0) の値: 40
座標 (1, 1) の値: 50
座標 (1, 2) の値: 60

このコードでは、WithIndicesメソッドがIEnumerable<(int, int, T)>を返すため、foreachでタプルの分解代入を使い、行・列・値を簡単に取得しています。

yield returnを使うことで、遅延評価かつメモリ効率の良い列挙が可能です。

パフォーマンステストと考察

拡張メソッドでインデックス付きの列挙を行う設計は、コードの可読性と保守性を大きく向上させますが、パフォーマンス面での影響も考慮する必要があります。

パフォーマンスのポイント

yield returnのオーバーヘッド

yield returnは状態マシンを生成し、列挙子を遅延生成します。

これにより、単純なforループよりも若干のオーバーヘッドが発生します。

ただし、通常の用途ではほとんど気にならないレベルです。

タプルの生成コスト

タプルは値型であり、軽量ですが大量の要素を列挙する場合は生成コストが積み重なります。

特に大規模な配列で頻繁に呼び出す場合は注意が必要です。

メモリ効率

拡張メソッドは遅延評価のため、全要素を一度にメモリに展開しません。

これによりメモリ使用量は抑えられますが、列挙時に毎回状態を保持するため、単純なループよりはわずかにメモリを消費します。

実際の計測例

以下は、1000×1000の2次元配列に対して、WithIndices拡張メソッドを使った列挙と、通常のforループでのアクセスを比較した簡単なパフォーマンステスト例です。

using System;
using System.Diagnostics;
using System.Collections.Generic;
static class ArrayExtensions
{
    public static IEnumerable<(int row, int col, T value)> WithIndices<T>(this T[,] array)
    {
        int rows = array.GetLength(0);
        int cols = array.GetLength(1);
        for (int row = 0; row < rows; row++)
            for (int col = 0; col < cols; col++)
                yield return (row, col, array[row, col]);
    }
}
class Program
{
    static void Main()
    {
        int size = 1000;
        int[,] matrix = new int[size, size];
        Random rand = new Random();
        // 配列を初期化
        for (int i = 0; i < size; i++)
            for (int j = 0; j < size; j++)
                matrix[i, j] = rand.Next(1000);
        Stopwatch sw = new Stopwatch();
        // 拡張メソッドで列挙
        sw.Start();
        long sum1 = 0;
        foreach (var (row, col, value) in matrix.WithIndices())
        {
            sum1 += value;
        }
        sw.Stop();
        Console.WriteLine($"WithIndices合計: {sum1}, 時間: {sw.ElapsedMilliseconds} ms");
        // 通常のforループで列挙
        sw.Restart();
        long sum2 = 0;
        for (int i = 0; i < size; i++)
            for (int j = 0; j < size; j++)
                sum2 += matrix[i, j];
        sw.Stop();
        Console.WriteLine($"forループ合計: {sum2}, 時間: {sw.ElapsedMilliseconds} ms");
    }
}

WithIndices合計: 499542522, 時間: 9 ms
forループ合計: 499542522, 時間: 1 ms

考察

WithIndices拡張メソッドはforループに比べて約9倍程度の時間がかかる結果となりました。これはyield returnの状態マシン生成やタプルの生成コストが影響しています
ただし、コードの可読性や保守性は大幅に向上するため、パフォーマンスが極端に重要でない場合は拡張メソッドの利用が推奨されます
パフォーマンスが最優先の場合は、forループで直接インデックスを扱う方法が最適です
また、JITコンパイラの最適化や環境によって結果は変動するため、実際の用途に応じてベンチマークを行うことが望ましいです

このように、拡張メソッドでforeachにインデックスを渡す設計は、利便性とパフォーマンスのバランスを考慮しながら使い分けることが重要です。

foreachとforの比較検証

多次元配列を扱う際、foreachとforのどちらを使うかはパフォーマンスや可読性に影響します。

ここでは、両者のコンパイル後のILコードの違い、キャッシュ効率やメモリアクセスパターン、そして可読性・保守性の観点から比較検証します。

コンパイル後ILの違い

C#のforeach文は、コンパイル時に対象の型に応じた列挙子(Enumerator)を使うコードに変換されます。

多次元配列の場合、foreachはSystem.ArrayのGetEnumerator()を呼び出し、IEnumeratorを使って要素を列挙します。

一方、for文は単純にインデックスを使ったループ構造に変換され、配列の要素に直接アクセスします。

以下に、2次元配列の全要素を列挙するforeachとforの簡単なコード例と、それぞれのILコードの特徴を示します。

int[,] matrix = new int[2, 3] { {1,2,3}, {4,5,6} };
// foreach版
foreach (var val in matrix)
{
    Console.Write(val);
}
// for版
for (int i = 0; i < matrix.GetLength(0); i++)
{
    for (int j = 0; j < matrix.GetLength(1); j++)
    {
        Console.Write(matrix[i, j]);
    }
}

foreachのILコードの特徴

GetEnumerator()メソッドを呼び出し、IEnumeratorを取得
MoveNext()とCurrentプロパティを使って要素を取得
列挙子の状態管理用の構造体やクラスが生成されます
間接呼び出しが多く、メソッド呼び出しのオーバーヘッドが発生

forのILコードの特徴

単純なループカウンタ変数の増減
配列のインデックスアクセス命令を直接使用
ループの展開や最適化がJITコンパイラで行いやすい
間接呼び出しがなく、処理が直線的

この違いにより、forループはILレベルでよりシンプルかつ効率的なコードになります。

foreachは抽象化が強いため、ILコードは複雑になりがちです。

キャッシュ効率とメモリアクセスパターン

多次元配列はメモリ上で連続した領域に格納されており、行優先(Row-major)で配置されています。

これを踏まえたアクセスパターンがキャッシュ効率に大きく影響します。

forループのキャッシュ効率

forループで行優先にアクセスする場合、メモリの連続領域を順に読み込むためCPUキャッシュのヒット率が高くなります。

例えば、外側のループが行、内側のループが列の場合、メモリの連続性を活かせます。

逆に、列優先でアクセスするとキャッシュミスが増え、パフォーマンスが低下します。

foreachのキャッシュ効率

foreachは配列の内部的な1次元的なメモリ領域を順に列挙するため、基本的に行優先のアクセスとなり、キャッシュ効率は良好です。

ただし、foreachは列挙子を介するため、わずかなオーバーヘッドが発生します。

ジャグ配列の場合

ジャグ配列は各行が独立した配列であるため、メモリの連続性が失われます。

forやforeachでアクセスしてもキャッシュ効率は低くなりやすいです。

可読性と保守性の観点

foreachのメリット

コードが簡潔で読みやすい
ループカウンタやインデックス計算を意識せずに済みます
コレクションの種類を問わず使えるため汎用性が高いでしょう
バグの原因となるインデックスの誤りを防げます

foreachのデメリット

インデックス情報が必要な処理には不向き
要素の書き換えができない(読み取り専用)
パフォーマンスがforに劣る場合があります

forのメリット

インデックスを自由に扱えるため、行列の座標情報を使った処理に適しています
要素の読み書きが直接可能です
パフォーマンス面で優れていることが多い

forのデメリット

ループカウンタの管理が必要で、コードがやや冗長になります
インデックスの誤りによるバグが発生しやすい
可読性がforeachに比べて劣る場合があります

総じて、単純に全要素を読み取るだけならforeachが簡潔で扱いやすいですが、インデックスを使った処理やパフォーマンス重視の場合はforループが適しています。

用途に応じて使い分けることが望ましいです。

例外処理と安全な列挙

多次元配列をforeachやforで列挙する際には、例外が発生しないように安全に処理を行うことが重要です。

特にnull配列の取り扱いや、要素の更新を伴う場合の注意点を押さえておく必要があります。

null配列の取り扱い

配列がnullの場合にforeachやforでアクセスしようとすると、NullReferenceExceptionが発生します。

多次元配列でも同様で、事前にnullチェックを行うことが安全な列挙の基本です。

int[,] matrix = null;
try
{
    foreach (var value in matrix)
    {
        Console.WriteLine(value);
    }
}
catch (NullReferenceException)
{
    Console.WriteLine("配列がnullです。処理を中断します。");
}

配列がnullです。処理を中断します。

このように例外をキャッチする方法もありますが、例外はコストが高いため、通常は事前にnullチェックを行うほうが望ましいです。

if (matrix != null)
{
    foreach (var value in matrix)
    {
        Console.WriteLine(value);
    }
}
else
{
    Console.WriteLine("配列がnullのため処理をスキップします。");
}

配列がnullのため処理をスキップします。

また、メソッドの引数として多次元配列を受け取る場合は、ArgumentNullExceptionを投げて呼び出し元に明示的に通知する設計も推奨されます。

void ProcessMatrix(int[,] matrix)
{
    if (matrix == null)
        throw new ArgumentNullException(nameof(matrix));
    foreach (var value in matrix)
    {
        // 処理
    }
}

このように、null配列の取り扱いは例外発生を防ぐために必須のチェックです。

要素更新を伴う場合の注意点

foreachは列挙子を通じて要素を読み取るため、配列の要素を直接更新することはできません。

多次元配列の要素を更新したい場合は、forループを使ってインデックスを指定し、直接代入する必要があります。

int[,] matrix = {
    { 1, 2 },
    { 3, 4 }
};
// 要素の更新はforループで行う
for (int i = 0; i < matrix.GetLength(0); i++)
{
    for (int j = 0; j < matrix.GetLength(1); j++)
    {
        matrix[i, j] += 10;
    }
}

foreachで要素を更新しようとするとコンパイルエラーになります。

foreach (var value in matrix)
{
    value += 10; // コンパイルエラー: 変更不可
}

fixedステートメントとの併用

多次元配列の要素を高速に更新したい場合、fixedステートメントを使って配列の先頭ポインタを取得し、アンセーフコードで直接メモリにアクセスする方法があります。

ただし、これは安全性を犠牲にするため、十分な理解と注意が必要です。

using System;
class Program
{
    unsafe static void Main()
    {
        int[,] matrix = {
            { 1, 2 },
            { 3, 4 }
        };
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        fixed (int* ptr = &matrix[0, 0])
        {
            for (int i = 0; i < rows * cols; i++)
            {
                ptr[i] += 10;
            }
        }
        // 結果表示
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                Console.Write(matrix[i, j] + " ");
            }
            Console.WriteLine();
        }
    }
}

11 12
13 14

この例では、fixedで配列の先頭要素のポインタを固定し、ポインタ演算で全要素にアクセスしています。

unsafeコードを使うため、プロジェクトの設定でアンセーフコードを許可する必要があります。

fixedを使う際の注意点は以下の通りです。

ポインタ操作はメモリ破壊やセキュリティリスクを伴うため、十分にテストすること
ガベージコレクションの影響を受けないようにfixedでメモリを固定する必要があります
アンセーフコードは可読性や保守性を低下させるため、必要最小限に留める

これらの例外処理と安全な列挙のポイントを押さえることで、多次元配列を扱う際のトラブルを未然に防ぎ、堅牢なコードを書くことができます。

3次元以上の配列への拡張

多次元配列は2次元だけでなく、3次元以上の配列もC#で扱えます。

3次元配列やそれ以上の次元を持つ配列を効率的に操作するためには、ネストされたforループの使い方やforeachによる一次元化の違いを理解し、デバッグ時には可視化ツールを活用することが重要です。

ネストされたforループのテンプレート

3次元以上の配列を操作する際は、各次元に対応したネストされたforループを使うのが基本です。

例えば、3次元配列int[,,]の場合は3重ループ、4次元配列なら4重ループとなります。

以下は3次元配列の全要素を走査し、値を表示するテンプレートコードです。

using System;
class Program
{
    static void Main()
    {
        int[,,] cube = new int[2, 3, 4]
        {
            {
                { 1, 2, 3, 4 },
                { 5, 6, 7, 8 },
                { 9, 10, 11, 12 }
            },
            {
                { 13, 14, 15, 16 },
                { 17, 18, 19, 20 },
                { 21, 22, 23, 24 }
            }
        };
        int dim0 = cube.GetLength(0);
        int dim1 = cube.GetLength(1);
        int dim2 = cube.GetLength(2);
        for (int i = 0; i < dim0; i++)
        {
            Console.WriteLine($"次元0のインデックス: {i}");
            for (int j = 0; j < dim1; j++)
            {
                Console.Write($"  次元1のインデックス: {j} -> ");
                for (int k = 0; k < dim2; k++)
                {
                    Console.Write(cube[i, j, k] + " ");
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
    }
}

次元0のインデックス: 0
  次元1のインデックス: 0 -> 1 2 3 4 
  次元1のインデックス: 1 -> 5 6 7 8 
  次元1のインデックス: 2 -> 9 10 11 12 

次元0のインデックス: 1
  次元1のインデックス: 0 -> 13 14 15 16 
  次元1のインデックス: 1 -> 17 18 19 20 
  次元1のインデックス: 2 -> 21 22 23 24

このように、各次元に対応したループをネストさせることで、3次元配列の全要素にアクセスできます。

4次元以上の場合も同様にループを増やして対応します。

foreachによる一次元化との比較

foreach文を使うと、多次元配列の要素は内部的に一次元化されて列挙されます。

3次元配列でも同様で、foreachは全要素を1次元のシーケンスとして扱います。

以下は3次元配列に対するforeachの例です。

using System;
class Program
{
    static void Main()
    {
        int[,,] cube = new int[2, 2, 2]
        {
            { { 1, 2 }, { 3, 4 } },
            { { 5, 6 }, { 7, 8 } }
        };
        foreach (var value in cube)
        {
            Console.Write(value + " ");
        }
    }
}

1 2 3 4 5 6 7 8

このように、foreachは3次元配列の要素を平坦化して順に列挙します。

インデックス情報は得られないため、座標を使った処理が必要な場合はforループを使うか、拡張メソッドでインデックス付き列挙を実装する必要があります。

foreachの利点はコードが簡潔で読みやすいことですが、インデックスを使った複雑な処理や要素の更新には不向きです。

可視化ツールを用いたデバッグ

多次元配列は次元が増えるほどデータ構造が複雑になり、デバッグが難しくなります。

可視化ツールを活用することで、配列の中身を直感的に把握しやすくなります。

Visual Studioのデバッグ機能

Visual Studioのデバッガは多次元配列の内容をツリー形式で表示できます。

配列変数をウォッチウィンドウやローカル変数ウィンドウに追加すると、各次元の要素を展開して確認可能です。

配列の各次元を展開して値を確認できます
特定のインデックスの値を直接編集できます
ブレークポイントで停止した状態で配列の状態を詳細に調査できます

外部ツールやライブラリ

データ可視化ライブラリ

数値データをグラフやヒートマップとして表示するライブラリを使うと、3次元以上の配列の傾向やパターンを視覚的に把握しやすくなります。

カスタムデバッグ用メソッド

配列の内容を文字列化してコンソールに出力するメソッドを作成し、特定の範囲やスライスを表示することも有効です。

static void Print3DArraySlice(int[,,] array, int fixedDim, int fixedIndex)
{
    int dim1 = array.GetLength(1);
    int dim2 = array.GetLength(2);
    Console.WriteLine($"次元0のインデックス {fixedIndex} のスライス:");
    for (int i = 0; i < dim1; i++)
    {
        for (int j = 0; j < dim2; j++)
        {
            Console.Write(array[fixedIndex, i, j] + " ");
        }
        Console.WriteLine();
    }
}

このようなメソッドを使うと、3次元配列の特定のスライスだけを簡単に確認できます。

3次元以上の多次元配列は、ネストされたforループでの明示的なインデックス管理が基本となり、foreachは簡単な読み取りに適しています。

デバッグ時にはVisual Studioの機能やカスタム可視化メソッドを活用し、複雑なデータ構造を効率的に把握しましょう。

マルチスレッド環境での多次元配列列挙

多次元配列の処理を高速化するために、マルチスレッドを活用するケースが増えています。

C#ではParallel.ForやParallel.ForEachを使って並列処理を簡単に実装できますが、多次元配列の列挙においてはスレッドセーフなインデックス計算やデータ競合の回避が重要です。

Parallel.ForとParallel.ForEachの選択

多次元配列の並列処理では、Parallel.ForとParallel.ForEachのどちらを使うかがポイントになります。

Parallel.For

インデックス範囲を指定してループを並列化します。

多次元配列の各次元のインデックスを明示的に管理できるため、行や列単位での分割処理に適しています。

Parallel.ForEach

コレクションの要素を列挙しながら並列処理します。

多次元配列はIEnumerableとして平坦化されるため、インデックス情報が失われます。

インデックスが不要な単純な要素処理に向いています。

スレッドセーフなインデックス計算

多次元配列の要素を並列に処理する場合、各スレッドが処理する要素のインデックスを正確に計算し、重複や抜け漏れがないようにする必要があります。

例えば、2次元配列int[,] matrixの全要素を並列処理する場合、Parallel.Forで行インデックスを分割し、各スレッドが担当する行の全列を処理する方法が一般的です。

using System;
using System.Threading.Tasks;
class Program
{
    static void Main()
    {
        int rows = 1000;
        int cols = 1000;
        int[,] matrix = new int[rows, cols];
        // 並列で行単位に処理
        Parallel.For(0, rows, i =>
        {
            for (int j = 0; j < cols; j++)
            {
                matrix[i, j] = i + j; // 例: 要素の更新
            }
        });
        Console.WriteLine("処理完了");
    }
}

この例では、Parallel.Forが行インデックスiを分割し、各スレッドが独立して行の全列を処理します。

これにより、インデックス計算は単純でスレッドセーフです。

一方、Parallel.ForEachを使う場合は、配列を平坦化したIEnumerableを渡すことになりますが、元の行・列のインデックスを復元するために計算が必要です。

これが複雑になるため、インデックスが必要な場合はParallel.Forのほうが扱いやすいです。

データ競合回避の方法

マルチスレッドで多次元配列を操作する際は、複数のスレッドが同じ要素に同時にアクセス・更新しないように注意が必要です。

データ競合が発生すると、予期しない結果や例外が起こる可能性があります。

排他制御の基本

スレッドごとに異なる要素を処理する

最も簡単で効率的な方法は、スレッド間で処理対象の要素を分割し、重複しないようにすることです。

上記のParallel.Forの例はこれに該当します。

ロック(lock)を使う

複数スレッドが同じ要素を更新する可能性がある場合は、lock文で排他制御を行います。

ただし、ロックはパフォーマンス低下の原因になるため、必要最小限に留めるべきです。

object syncObj = new object();
Parallel.For(0, rows, i =>
{
    for (int j = 0; j < cols; j++)
    {
        lock (syncObj)
        {
            matrix[i, j] += 1; // 排他制御付き更新
        }
    }
});

この例は安全ですが、全要素でロックをかけるため非常に遅くなります。

スレッドセーフな集約処理

複数スレッドで部分的に計算した結果を集約する場合は、System.Threading.Interlockedクラスのメソッドを使うと効率的です。

例えば、合計値の計算などです。

using System.Threading;
long totalSum = 0;
Parallel.For(0, rows, i =>
{
    long localSum = 0;
    for (int j = 0; j < cols; j++)
    {
        localSum += matrix[i, j];
    }
    Interlocked.Add(ref totalSum, localSum);
});
Console.WriteLine($"合計値: {totalSum}");

この方法はロックより軽量で、スレッドセーフに集約できます。

マルチスレッド環境で多次元配列を安全かつ効率的に列挙・更新するには、Parallel.Forを使ってインデックスを明示的に管理し、スレッド間の処理範囲を分割することが基本です。

データ競合を避けるために、排他制御やInterlockedを適切に活用しましょう。

メモリとパフォーマンス最適化

多次元配列を扱う際、特に大規模なデータや高頻度の処理ではメモリ効率とパフォーマンスの最適化が重要になります。

ここでは、ArrayPoolを使ったメモリの再利用、Span<T>やMemory<T>との連携、そしてジャグ配列への変換を用いた高速化手法について解説します。

ArrayPoolレンタルの利用

ArrayPool<T>は.NET標準ライブラリに含まれる配列のプール機構で、一時的に大量の配列を確保・解放する際のメモリ割り当てコストを削減できます。

多次元配列の処理で一時的なバッファや変換用の配列を使う場合に効果的です。

利用例：一時的な1次元配列のレンタル

多次元配列の要素を一時的に1次元配列にコピーして処理したい場合、ArrayPool<T>.Shared.Rentで配列を借り、処理後に返却します。

using System;
using System.Buffers;
class Program
{
    static void Main()
    {
        int[,] matrix = {
            { 1, 2, 3 },
            { 4, 5, 6 }
        };
        int length = matrix.Length;
        int[] buffer = ArrayPool<int>.Shared.Rent(length);
        try
        {
            // 多次元配列の要素を1次元配列にコピー
            Buffer.BlockCopy(matrix, 0, buffer, 0, length * sizeof(int));
            // バッファを使った処理例：合計計算
            int sum = 0;
            for (int i = 0; i < length; i++)
            {
                sum += buffer[i];
            }
            Console.WriteLine($"合計: {sum}");
        }
        finally
        {
            // バッファを返却
            ArrayPool<int>.Shared.Return(buffer);
        }
    }
}

合計: 21

この方法は、毎回新しい配列を確保するよりGC負荷を軽減し、パフォーマンス向上に寄与します。

ただし、返却後は配列の内容が不定になるため、再利用時は注意が必要です。

Span<T>やMemory<T>との連携

Span<T>とMemory<T>は、配列やメモリ領域を安全かつ効率的に扱うための構造体で、特にパフォーマンスクリティカルな処理に適しています。

多次元配列の一部をスライスして操作したり、アンセーフコードを使わずに高速アクセスを実現できます。

多次元配列の一部をSpan<T>で扱う例

多次元配列は連続したメモリに格納されているため、MemoryMarshal.CreateSpanを使って内部の1次元メモリとしてSpan<T>を作成できます。

using System;
using System.Runtime.InteropServices;
class Program
{
    static void Main()
    {
        int[,] matrix = {
            { 10, 20, 30 },
            { 40, 50, 60 }
        };
        // 多次元配列の先頭要素の参照を取得
        ref int firstElement = ref matrix[0, 0];
        // Spanを作成(Lengthは全要素数)
        Span<int> span = MemoryMarshal.CreateSpan(ref firstElement, matrix.Length);
        // Spanを使って要素を更新
        for (int i = 0; i < span.Length; i++)
        {
            span[i] += 5;
        }
        // 結果表示
        for (int i = 0; i < matrix.GetLength(0); i++)
        {
            for (int j = 0; j < matrix.GetLength(1); j++)
            {
                Console.Write(matrix[i, j] + " ");
            }
            Console.WriteLine();
        }
    }
}

15 25 35
45 55 65

この方法はアンセーフコードを使わずに高速なメモリアクセスを実現し、GCの影響も受けにくいです。

Memory<T>は非同期処理やヒープ上のメモリ管理に適しています。

ジャグ配列への変換を用いた高速化

多次元配列は連続メモリに格納されるためキャッシュ効率が良い一方、サイズ変更ができず柔軟性に欠けます。

ジャグ配列(配列の配列)は各行が独立しているため、行ごとに異なる長さを持てる柔軟性がありますが、メモリの連続性は失われます。

ジャグ配列への変換メリット

柔軟なサイズ変更

行ごとに異なる長さの配列を持てるため、可変長データに対応可能です。

部分的な高速化

行単位での処理を並列化しやすく、特定の行だけを効率的に操作できます。

メモリ断片化の回避

大きな連続メモリ確保が不要なため、メモリ断片化の影響を受けにくい。

変換例

using System;
class Program
{
    static void Main()
    {
        int[,] matrix = {
            { 1, 2, 3 },
            { 4, 5, 6 }
        };
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        // ジャグ配列に変換
        int[][] jagged = new int[rows][];
        for (int i = 0; i < rows; i++)
        {
            jagged[i] = new int[cols];
            for (int j = 0; j < cols; j++)
            {
                jagged[i][j] = matrix[i, j];
            }
        }
        // ジャグ配列の処理例：各行の合計を計算
        for (int i = 0; i < jagged.Length; i++)
        {
            int sum = 0;
            for (int j = 0; j < jagged[i].Length; j++)
            {
                sum += jagged[i][j];
            }
            Console.WriteLine($"行 {i} の合計: {sum}");
        }
    }
}

行 0 の合計: 6
行 1 の合計: 15

ジャグ配列は行ごとの処理や並列化に適しており、特に行長が異なる場合や動的にサイズを変更する必要がある場合に有効です。

ただし、メモリの連続性が失われるため、連続アクセスが多い処理では多次元配列のほうが高速になることがあります。

これらの手法を組み合わせることで、多次元配列のメモリ使用効率と処理速度を最適化できます。

用途やデータ特性に応じて適切な方法を選択しましょう。

典型的なユースケース別サンプル

多次元配列は様々な分野で活用されており、特に画像処理、数値シミュレーション、Excelデータの読み込みなどで頻繁に使われます。

ここではそれぞれの典型的なユースケースにおけるサンプルコードを示し、foreachやforを使った多次元配列の操作方法を解説します。

画像データのピクセル操作

画像データは一般的に2次元のピクセル配列として表現されます。

各ピクセルはRGBやグレースケールの値を持ち、多次元配列やジャグ配列で管理されることが多いです。

以下は、2次元配列で表現したグレースケール画像のピクセル値を反転(ネガポジ変換)する例です。

using System;
class Program
{
    static void Main()
    {
        // 5x5のグレースケール画像(0-255の輝度値)
        byte[,] image = {
            { 0, 50, 100, 150, 200 },
            { 10, 60, 110, 160, 210 },
            { 20, 70, 120, 170, 220 },
            { 30, 80, 130, 180, 230 },
            { 40, 90, 140, 190, 240 }
        };
        int height = image.GetLength(0);
        int width = image.GetLength(1);
        // 反転画像を格納する配列
        byte[,] inverted = new byte[height, width];
        for (int i = 0; i < height; i++)
        {
            for (int j = 0; j < width; j++)
            {
                inverted[i, j] = (byte)(255 - image[i, j]);
            }
        }
        // 結果表示
        Console.WriteLine("反転画像のピクセル値:");
        for (int i = 0; i < height; i++)
        {
            for (int j = 0; j < width; j++)
            {
                Console.Write($"{inverted[i, j],3} ");
            }
            Console.WriteLine();
        }
    }
}

反転画像のピクセル値:
255 205 155 105  55 
245 195 145  95  45 
235 185 135  85  35 
225 175 125  75  25 
215 165 115  65  15

この例では、forループで行・列を指定して各ピクセルを反転しています。

foreachでも列挙は可能ですが、インデックスが必要なためforが適しています。

数値シミュレーションの格子データ

物理シミュレーションや数値解析では、3次元やそれ以上の格子状データを多次元配列で管理し、各格子点の値を更新しながら計算を進めます。

以下は、3次元配列で表現した格子データの初期化と単純な更新処理の例です。

using System;
class Program
{
    static void Main()
    {
        int dimX = 4;
        int dimY = 4;
        int dimZ = 4;
        double[,,] grid = new double[dimX, dimY, dimZ];
        // 初期化：座標の和を値とする
        for (int x = 0; x < dimX; x++)
        {
            for (int y = 0; y < dimY; y++)
            {
                for (int z = 0; z < dimZ; z++)
                {
                    grid[x, y, z] = x + y + z;
                }
            }
        }
        // 更新処理：隣接格子点の平均を計算(境界は無視)
        double[,,] updatedGrid = new double[dimX, dimY, dimZ];
        for (int x = 1; x < dimX - 1; x++)
        {
            for (int y = 1; y < dimY - 1; y++)
            {
                for (int z = 1; z < dimZ - 1; z++)
                {
                    double sum = 0;
                    sum += grid[x - 1, y, z];
                    sum += grid[x + 1, y, z];
                    sum += grid[x, y - 1, z];
                    sum += grid[x, y + 1, z];
                    sum += grid[x, y, z - 1];
                    sum += grid[x, y, z + 1];
                    updatedGrid[x, y, z] = sum / 6.0;
                }
            }
        }
        // 結果の一部表示
        Console.WriteLine("更新後の格子点の値(一部):");
        for (int x = 1; x < dimX - 1; x++)
        {
            for (int y = 1; y < dimY - 1; y++)
            {
                for (int z = 1; z < dimZ - 1; z++)
                {
                    Console.WriteLine($"({x},{y},{z}): {updatedGrid[x, y, z]:F2}");
                }
            }
        }
    }
}

更新後の格子点の値(一部):
(1,1,1): 3.00
(1,1,2): 4.00
(1,2,1): 4.00
(1,2,2): 5.00
(2,1,1): 4.00
(2,1,2): 5.00
(2,2,1): 5.00
(2,2,2): 6.00

このように、3次元配列を使って格子点の値を管理し、隣接点の値を参照して更新する典型的な数値シミュレーションの処理が行えます。

Excelシートデータの読み込み

Excelのシートデータは行と列の2次元構造を持つため、多次元配列やジャグ配列で表現することが多いです。

C#ではEPPlusやClosedXMLなどのライブラリを使ってExcelファイルを読み込み、配列に格納できます。

EPPlus 8.0.4

A spreadsheet library for .NET framework and .NET core

以下はEPPlusを使ってExcelのシートを読み込み、2次元配列に格納する例です。

using System;
using OfficeOpenXml;
using System.IO;
class Program
{
    static void Main()
    {
        // EPPlusのライセンス設定(非商用利用の場合)
        ExcelPackage.LicenseContext = LicenseContext.NonCommercial;
        string filePath = "sample.xlsx";
        using (var package = new ExcelPackage(new FileInfo(filePath)))
        {
            var worksheet = package.Workbook.Worksheets[0];
            int rows = worksheet.Dimension.Rows;
            int cols = worksheet.Dimension.Columns;
            string[,] data = new string[rows, cols];
            for (int i = 1; i <= rows; i++)
            {
                for (int j = 1; j <= cols; j++)
                {
                    data[i - 1, j - 1] = worksheet.Cells[i, j].Text;
                }
            }
            // 読み込んだデータの表示(例：1行目)
            Console.WriteLine("1行目のデータ:");
            for (int j = 0; j < cols; j++)
            {
                Console.Write(data[0, j] + "\t");
            }
            Console.WriteLine();
        }
    }
}

このコードはExcelファイルの最初のシートを読み込み、セルのテキストを2次元配列に格納します。

EPPlusはNuGetからインストール可能で、Excel操作に便利なライブラリです。

これらのサンプルは、多次元配列を使った典型的なユースケースの一例です。

用途に応じてforループやforeachを使い分け、効率的かつ可読性の高いコードを書くことが重要です。

LINQでの多次元配列操作

C#のLINQはコレクション操作を簡潔に記述できる強力な機能で、多次元配列の操作にも応用できます。

ここでは、SelectManyを使った多次元配列の平坦化、行列の変形(Transpose)の実装例、そして拡張メソッドを用いたカスタムクエリの作成方法を解説します。

SelectManyでの平坦化

多次元配列はIEnumerableとして扱うと平坦化されますが、LINQのSelectManyを使うと、ジャグ配列や配列の配列のようなネストされた構造を1次元に展開する際に便利です。

例えば、ジャグ配列int[][]を1次元のシーケンスに平坦化する例を示します。

using System;
using System.Linq;
class Program
{
    static void Main()
    {
        int[][] jagged = new int[][]
        {
            new int[] {1, 2, 3},
            new int[] {4, 5},
            new int[] {6, 7, 8, 9}
        };
        // SelectManyで平坦化
        var flat = jagged.SelectMany(row => row);
        Console.WriteLine("平坦化された要素:");
        foreach (var val in flat)
        {
            Console.Write(val + " ");
        }
    }
}

平坦化された要素:
1 2 3 4 5 6 7 8 9

SelectManyは各行(配列)を展開し、すべての要素を連結して1次元の列挙子を返します。

多次元配列int[,]の場合はCast<int>()で平坦化できますが、ジャグ配列のようなネスト構造にはSelectManyが適しています。

変形(Transpose)の実装例

行列の転置(Transpose)は、行と列を入れ替える操作で、多次元配列の操作でよく使われます。

LINQを使うと簡潔に実装可能です。

以下は2次元配列int[,]の転置を行い、新しい配列を返す例です。

using System;
using System.Linq;
class Program
{
    static int[,] Transpose(int[,] matrix)
    {
        int rows = matrix.GetLength(0);
        int cols = matrix.GetLength(1);
        int[,] result = new int[cols, rows];
        // LINQを使って転置
        var transposed = Enumerable.Range(0, cols)
            .SelectMany(col => Enumerable.Range(0, rows)
                .Select(row => new { Row = col, Col = row, Value = matrix[row, col] }));
        foreach (var item in transposed)
        {
            result[item.Row, item.Col] = item.Value;
        }
        return result;
    }
    static void Main()
    {
        int[,] matrix = {
            {1, 2, 3},
            {4, 5, 6}
        };
        int[,] transposed = Transpose(matrix);
        int rows = transposed.GetLength(0);
        int cols = transposed.GetLength(1);
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                Console.Write(transposed[i, j] + " ");
            }
            Console.WriteLine();
        }
    }
}

1 4
2 5
3 6

この例では、Enumerable.Rangeで列と行のインデックスを生成し、SelectManyとSelectで転置後の位置と値を取得しています。

結果を新しい配列に格納して返しています。

拡張メソッドによるカスタムクエリ

LINQの拡張メソッドを自作することで、多次元配列に特化したカスタムクエリを実装できます。

例えば、2次元配列の各要素にインデックス情報を付加して列挙する拡張メソッドを作成すると、foreachやLINQクエリでインデックス付きの操作が可能になります。

以下は、2次元配列の要素と行・列のインデックスを返す拡張メソッドの例です。

using System;
using System.Collections.Generic;
static class ArrayExtensions
{
    public static IEnumerable<(int Row, int Col, T Value)> WithIndices<T>(this T[,] array)
    {
        int rows = array.GetLength(0);
        int cols = array.GetLength(1);
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                yield return (i, j, array[i, j]);
            }
        }
    }
}
class Program
{
    static void Main()
    {
        int[,] matrix = {
            { 10, 20 },
            { 30, 40 }
        };
        // 拡張メソッドを使ったLINQクエリ例
        var filtered = matrix.WithIndices()
            .Where(x => x.Value > 15)
            .Select(x => $"({x.Row},{x.Col})={x.Value}");
        foreach (var item in filtered)
        {
            Console.WriteLine(item);
        }
    }
}

(0,1)=20
(1,0)=30
(1,1)=40

この拡張メソッドを使うと、インデックス情報を含めた柔軟なクエリが可能になり、多次元配列の操作がより直感的になります。

LINQを活用することで、多次元配列の平坦化や変形、カスタムクエリの作成が簡潔に行えます。

用途に応じてSelectManyや拡張メソッドを使い分け、効率的なデータ操作を実現しましょう。

罠とよくあるミス

多次元配列を扱う際には、初心者から経験者まで陥りやすい罠やミスがいくつか存在します。

ここでは特に注意すべき「入れ子foreachによる重複ループ」「ジャグ配列と多次元配列の混同」「配列サイズ変更の誤解」について詳しく解説します。

入れ子foreachによる重複ループ

多次元配列をforeachで処理する際、2次元以上の配列に対して入れ子のforeachを使うと、意図しない重複ループになることがあります。

典型的なミス例

int[,] matrix = {
    {1, 2},
    {3, 4}
};
foreach (var row in matrix)
{
    foreach (var elem in matrix)
    {
        Console.WriteLine(elem);
    }
}

このコードは、matrixの要素を2重に列挙しているため、合計4×4=16回の出力が発生します。

foreachは多次元配列を平坦化して1次元的に列挙するため、rowもelemも同じ全要素の列挙子を指しており、行ごとの区切りがありません。

正しい使い方

多次元配列の行ごとに処理したい場合は、forループで行・列のインデックスを使うか、ジャグ配列のように行単位で配列を分けてからforeachを使います。

int[,] matrix = {
    {1, 2},
    {3, 4}
};
int rows = matrix.GetLength(0);
int cols = matrix.GetLength(1);
for (int i = 0; i < rows; i++)
{
    Console.Write("行 " + i + ": ");
    for (int j = 0; j < cols; j++)
    {
        Console.Write(matrix[i, j] + " ");
    }
    Console.WriteLine();
}

このように、forループで明示的に行・列を指定することで、重複ループを防げます。

ジャグ配列と多次元配列の混同

C#には「多次元配列int[,]など)」と「ジャグ配列(配列の配列、int[][]」という異なる配列構造があります。

これらを混同すると、コンパイルエラーや実行時エラーの原因になります。

違いのポイント

特徴	多次元配列 `(int[,])`	ジャグ配列 `(int[][])`
宣言例	`int[,] matrix = new int[3,4];`	`int[][] jagged = new int[3][];`
要素アクセス	`matrix[i, j]`	`jagged[i][j]`
各行の長さ	固定	可変
メモリ配置	連続	行ごとに独立

よくあるミス例

int[,] matrix = new int[2, 3];
int[][] jagged = new int[2][];
// コンパイルエラー: 多次元配列にジャグ配列のようにアクセス
int val = matrix[0][1]; // NG
// コンパイルエラー: ジャグ配列に多次元配列のようにアクセス
int val2 = jagged[0, 1]; // NG

対応策

多次元配列は[,]で宣言し、matrix[i, j]でアクセスします
ジャグ配列は[][]で宣言し、jagged[i][j]でアクセスします
どちらを使うかは用途に応じて選択し、混用しない

配列サイズ変更の誤解

C#の配列は固定長であり、一度作成した配列のサイズを変更できません。

この点を誤解して、サイズ変更を試みるコードを書くとエラーや意図しない動作になります。

よくある誤解例

int[] array = new int[5];
array.Length = 10; // コンパイルエラー

また、多次元配列やジャグ配列でも同様に、既存の配列のサイズを変更することはできません。

サイズ変更が必要な場合の対処法

新しい配列を作成してコピーする

サイズを変更したい場合は、新しい配列を作成し、既存の要素をコピーしてから新しい配列を使います。

int[] oldArray = {1, 2, 3};
int[] newArray = new int[5];
Array.Copy(oldArray, newArray, oldArray.Length);

List<T>などの可変長コレクションを使う

サイズ変更が頻繁に必要な場合は、List<T>や他のコレクションを使うほうが効率的です。

ジャグ配列で行ごとに可変長を持つ

ジャグ配列は各行の長さを独立して設定できるため、行ごとに異なるサイズを持たせたい場合に有効です。

これらの罠やミスを理解し、適切な配列の使い方とループ構造を選ぶことで、多次元配列の扱いでのトラブルを防ぎ、安定したコードを書くことができます。

申し訳ありませんが、「参考リンクと学習リソース」については作成しないようご指示いただいておりますので、本文の作成は控えさせていただきます。

まとめ

この記事では、C#における多次元配列の基本から応用まで幅広く解説しました。

foreachによる平坦化の仕組みやインデックス情報の扱い方、拡張メソッドによるインデックス付き列挙、マルチスレッド処理やメモリ最適化の手法も紹介しています。

さらに、典型的なユースケースやLINQ活用例、よくあるミスも取り上げ、実践的な知識を提供しました。

これにより、多次元配列を効率的かつ安全に扱うための理解が深まります。

2025-04-30更新日: 2025-04-30