这可能在上面的回答中提到过，但没有明确地提到:对于锯齿数组，您可以使用array[row]引用整行数据，但这对于多维数组是不允许的。

数组的数组(锯齿数组)比多维数组更快，可以更有效地使用。多维数组有更好的语法。

如果你使用交错数组和多维数组写一些简单的代码，然后用IL反汇编器检查编译后的程序集，你会发现从交错数组(或一维数组)中存储和检索是简单的IL指令，而多维数组的相同操作是方法调用，总是比较慢。

考虑以下方法:

static void SetElementAt(int[][] array, int i, int j, int value)
{
    array[i][j] = value;
}

static void SetElementAt(int[,] array, int i, int j, int value)
{
    array[i, j] = value;
}

他们的IL将如下:

.method private hidebysig static void  SetElementAt(int32[][] 'array',
                                                    int32 i,
                                                    int32 j,
                                                    int32 'value') cil managed
{
  // Code size       7 (0x7)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  ldarg.1
  IL_0002:  ldelem.ref
  IL_0003:  ldarg.2
  IL_0004:  ldarg.3
  IL_0005:  stelem.i4
  IL_0006:  ret
} // end of method Program::SetElementAt

.method private hidebysig static void  SetElementAt(int32[0...,0...] 'array',
                                                    int32 i,
                                                    int32 j,
                                                    int32 'value') cil managed
{
  // Code size       10 (0xa)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  ldarg.1
  IL_0002:  ldarg.2
  IL_0003:  ldarg.3
  IL_0004:  call       instance void int32[0...,0...]::Set(int32,
                                                           int32,
                                                           int32)
  IL_0009:  ret
} // end of method Program::SetElementAt

当使用锯齿状数组时，可以轻松地执行行交换和行大小调整等操作。也许在某些情况下使用多维数组会更安全，但即使Microsoft FxCop也告诉我们，当您使用锯齿数组来分析您的项目时，应该使用锯齿数组而不是多维数组。

除了其他答案之外，请注意，多维数组被分配为堆上的一个大块对象。这有一些含义:

Some multidimensional arrays will get allocated on the Large Object Heap (LOH) where their equivalent jagged array counterparts would otherwise not have. The GC will need to find a single contiguous free block of memory to allocate a multidimensional array, whereas a jagged array might be able to fill in gaps caused by heap fragmentation... this isn't usually an issue in .NET because of compaction, but the LOH doesn't get compacted by default (you have to ask for it, and you have to ask every time you want it). You'll want to look into <gcAllowVeryLargeObjects> for multidimensional arrays way before the issue will ever come up if you only ever use jagged arrays.

简单地说，多维数组类似于DBMS中的表。 Array of Array(锯齿状数组)允许每个元素保存另一个相同类型的可变长度数组。

因此，如果您确定数据结构看起来像一个表(固定的行/列)，您可以使用多维数组。锯齿数组是固定的元素&每个元素可以容纳一个可变长度的数组

例如Psuedocode:

int[,] data = new int[2,2];
data[0,0] = 1;
data[0,1] = 2;
data[1,0] = 3;
data[1,1] = 4;

我们可以把上面的表格看成一个2x2的表格:

1 | 2 3 | 4

int[][] jagged = new int[3][]; 
jagged[0] = new int[4] {  1,  2,  3,  4 }; 
jagged[1] = new int[2] { 11, 12 }; 
jagged[2] = new int[3] { 21, 22, 23 }; 

可以把上面的代码看成每一行都有可变的列数:

1 | 2 | 3 | 4 11 | 12 21 | | 22, 23

多维数组创建了一个很好的线性内存布局，而锯齿数组意味着几个额外的间接层次。

在一个jagged数组中查找值jagged[3][6] var jagged = new int[10][5]的工作方式如下:查找索引为3的元素(这是一个数组)，并查找该数组中索引为6的元素(这是一个值)。对于本例中的每个维度，都需要进行额外的查找(这是一种开销很大的内存访问模式)。

多维数组在内存中线性排列，实际值通过将索引相乘得到。然而，给定数组var mult = new int[10,30]，该多维数组的Length属性将返回元素的总数，即10 * 30 = 300。

锯齿数组的Rank属性总是1，但多维数组可以有任何Rank。任何数组的GetLength方法都可以用于获取每个维度的长度。对于本例中的多维数组，multi . getlength(1)返回30。

索引多维数组更快。例如，给定这个例子中的多维数组mult[1,7] = 30 * 1 + 7 = 37，获取索引为37的元素。这是一种更好的内存访问模式，因为只涉及一个内存位置，即数组的基址。

多维数组因此分配一个连续的内存块，而锯齿状数组不一定是正方形的，例如jagged[1]。长度不一定等于锯齿状的[2]。长度，这对任何多维数组都成立。

性能

在性能方面，多维数组应该更快。快了很多，但由于一个非常糟糕的CLR实现，它们没有。

 23.084  16.634  15.215  15.489  14.407  13.691  14.695  14.398  14.551  14.252 
 25.782  27.484  25.711  20.844  19.607  20.349  25.861  26.214  19.677  20.171 
  5.050   5.085   6.412   5.225   5.100   5.751   6.650   5.222   6.770   5.305 

第一行是锯齿数组的计时，第二行是多维数组第三行，应该是这样的。该程序如下所示，仅供参考，这是测试运行mono。(窗口时间有很大的不同，主要是由于CLR实现的变化)。

在窗口上，锯齿数组的计时非常优越，与我自己对多维数组查找应该是什么样子的解释大致相同，请参阅“Single()”。不幸的是，windows的jit编译器真的很愚蠢，这使得这些性能讨论很困难，有太多的不一致。

这些是我在windows上得到的时间，这里也是一样，第一行是锯齿数组，第二行是多维的，第三行是我自己的多维实现，注意这在windows上比mono慢多了。

  8.438   2.004   8.439   4.362   4.936   4.533   4.751   4.776   4.635   5.864
  7.414  13.196  11.940  11.832  11.675  11.811  11.812  12.964  11.885  11.751
 11.355  10.788  10.527  10.541  10.745  10.723  10.651  10.930  10.639  10.595

源代码:

using System;
using System.Diagnostics;
static class ArrayPref
{
    const string Format = "{0,7:0.000} ";
    static void Main()
    {
        Jagged();
        Multi();
        Single();
    }

    static void Jagged()
    {
        const int dim = 100;
        for(var passes = 0; passes < 10; passes++)
        {
            var timer = new Stopwatch();
            timer.Start();
            var jagged = new int[dim][][];
            for(var i = 0; i < dim; i++)
            {
                jagged[i] = new int[dim][];
                for(var j = 0; j < dim; j++)
                {
                    jagged[i][j] = new int[dim];
                    for(var k = 0; k < dim; k++)
                    {
                        jagged[i][j][k] = i * j * k;
                    }
                }
            }
            timer.Stop();
            Console.Write(Format,
                (double)timer.ElapsedTicks/TimeSpan.TicksPerMillisecond);
        }
        Console.WriteLine();
    }

    static void Multi()
    {
        const int dim = 100;
        for(var passes = 0; passes < 10; passes++)
        {
            var timer = new Stopwatch();
            timer.Start();
            var multi = new int[dim,dim,dim];
            for(var i = 0; i < dim; i++)
            {
                for(var j = 0; j < dim; j++)
                {
                    for(var k = 0; k < dim; k++)
                    {
                        multi[i,j,k] = i * j * k;
                    }
                }
            }
            timer.Stop();
            Console.Write(Format,
                (double)timer.ElapsedTicks/TimeSpan.TicksPerMillisecond);
        }
        Console.WriteLine();
    }

    static void Single()
    {
        const int dim = 100;
        for(var passes = 0; passes < 10; passes++)
        {
            var timer = new Stopwatch();
            timer.Start();
            var single = new int[dim*dim*dim];
            for(var i = 0; i < dim; i++)
            {
                for(var j = 0; j < dim; j++)
                {
                    for(var k = 0; k < dim; k++)
                    {
                        single[i*dim*dim+j*dim+k] = i * j * k;
                    }
                }
            }
            timer.Stop();
            Console.Write(Format,
                (double)timer.ElapsedTicks/TimeSpan.TicksPerMillisecond);
        }
        Console.WriteLine();
    }
}

多维数组是(n-1)维矩阵。

所以int[，] square = new int[2,2]是一个方阵2x2, int[，] cube = new int[3,3,3]是一个立方-方阵3x3。比例不是必需的。

交错数组只是数组的数组——每个单元格包含一个数组的数组。

所以MDA是成比例的，JD可能不是!每个单元格可以包含任意长度的数组!