嘿，我来帮你搞定这个需求！你想要的其实是一个三维层级的数组结构——简单说就是「数组里装着数组，而这些数组里又装着int数组」。下面给你两种最常用的实现方式，适配不同的场景：

1. 规整三维数组（Rectangular Array） #

因为你的结构非常规整：3行 × 每行3个数组 × 每个数组3个int，用C#的三维矩形数组是最直接的选择，它的内存是连续分配的，访问效率也高。

实现代码 #

// 直接声明并初始化整个三维数组
int[,,] threeDArray = new int[3, 3, 3]
{
    {
        {1, 2, 3},   // 第一行的第一个小数组
        {4, 5, 6},   // 第一行的第二个小数组
        {7, 8, 9}    // 第一行的第三个小数组
    },
    {
        {10, 11, 12}, // 第二行的第一个小数组
        {13, 14, 15}, // 第二行的第二个小数组
        {16, 17, 18}  // 第二行的第三个小数组
    },
    {
        {19, 20, 21}, // 第三行的第一个小数组
        {22, 23, 24}, // 第三行的第二个小数组
        {25, 26, 27}  // 第三行的第三个小数组
    }
};

// 访问示例：取第二行第三个小数组的第二个元素（索引从0开始）
int value = threeDArray[1, 2, 1]; // 结果是17

如果你想分步初始化（像你原来的交错数组那样），也可以这么写：

int[,,] threeDArray = new int[3, 3, 3];

// 给第一行的三个小数组赋值
threeDArray[0, 0] = new int[] {1, 3, 5};
threeDArray[0, 1] = new int[] {2, 4, 6};
threeDArray[0, 2] = new int[] {7, 8, 9};

// 给第二行赋值
threeDArray[1, 0] = new int[] {0, 2, 4};
threeDArray[1, 1] = new int[] {1, 3, 5};
threeDArray[1, 2] = new int[] {6, 7, 8};

// 给第三行赋值
threeDArray[2, 0] = new int[] {11, 22, 33};
threeDArray[2, 1] = new int[] {44, 55, 66};
threeDArray[2, 2] = new int[] {77, 88, 99};

2. 嵌套交错数组（Jagged Array of Jagged Arrays） #

如果你以后可能需要灵活调整每行的小数组数量（比如某一行可能有4个小数组，另一行只有2个），那用**int[][][]**这种嵌套交错数组更合适，它的每个子数组长度可以独立设置。

实现代码 #

// 先创建外层数组（3行）
int[][][] jagged3D = new int[3][][];

// 给第一行初始化3个int数组
jagged3D[0] = new int[][]
{
    new int[] {1, 3, 5},
    new int[] {2, 4, 6},
    new int[] {7, 8, 9}
};

// 给第二行初始化3个int数组
jagged3D[1] = new int[][]
{
    new int[] {0, 2, 4},
    new int[] {1, 3, 5},
    new int[] {6, 7, 8}
};

// 给第三行初始化3个int数组
jagged3D[2] = new int[][]
{
    new int[] {11, 22, 33},
    new int[] {44, 55, 66},
    new int[] {77, 88, 99}
};

// 访问示例：取第三行第一个小数组的第三个元素
int value = jagged3D[2][0][2]; // 结果是33

两种方式的小区别 #

• 三维矩形数组（int[,,]）：结构固定，内存连续，访问速度快，完全匹配你的规整场景。
• 嵌套交错数组（int[][][]）：更灵活，每个子数组长度可以不一样，但内存是分散的，访问效率略低一点。

内容的提问来源于stack exchange，提问作者john