前言:本评论旨在解决okutane提供的关于锯齿数组和多维数组之间性能差异的答案。

一种类型因为方法调用而比另一种类型慢的断言是不正确的。其中一种比另一种慢，因为它的边界检查算法更复杂。您可以通过查看编译后的程序集而不是IL轻松验证这一点。例如，在我的4.5安装中，访问存储在ecx指向的二维数组中的元素(通过edx中的指针)，索引存储在eax和edx中，如下所示:

sub eax,[ecx+10]
cmp eax,[ecx+08]
jae oops //jump to throw out of bounds exception
sub edx,[ecx+14]
cmp edx,[ecx+0C]
jae oops //jump to throw out of bounds exception
imul eax,[ecx+0C]
add eax,edx
lea edx,[ecx+eax*4+18]

Here, you can see that there's no overhead from method calls. The bounds checking is just very convoluted thanks to the possibility of non-zero indexes, which is a functionality not on offer with jagged arrays. If we remove the sub, cmp, and jmps for the non-zero cases, the code pretty much resolves to (x*y_max+y)*sizeof(ptr)+sizeof(array_header). This calculation is about as fast (one multiply could be replaced by a shift, since that's the whole reason we choose bytes to be sized as powers of two bits) as anything else for random access to an element.

Another complication is that there are plenty of cases where a modern compiler will optimize away the nested bounds-checking for element access while iterating over a single-dimension array. The result is code that basically just advances an index pointer over the contiguous memory of the array. Naive iteration over multi-dimensional arrays generally involves an extra layer of nested logic, so a compiler is less likely to optimize the operation. So, even though the bounds-checking overhead of accessing a single element amortizes out to constant runtime with respect to array dimensions and sizes, a simple test-case to measure the difference may take many times longer to execute.

我想从未来开始，我应该在这里补充一些。net 5的性能结果，因为从现在开始，它将成为每个人都使用的平台。

这些测试与约翰·雷德格伦(2009年)使用的测试相同。

我的结果。净5.0.1):

  Debug:
  (Jagged)
  5.616   4.719   4.778   5.524   4.559   4.508   5.913   6.107   5.839   5.270
  
  (Multi)
  6.336   7.477   6.124   5.817   6.516   7.098   5.272   6.091  25.034   6.023
  
  (Single)
  4.688   3.494   4.425   6.176   4.472   4.347   4.976   4.754   3.591   4.403


  Release(code optimizations on):
  (Jagged)
  2.614   2.108   3.541   3.065   2.172   2.936   1.681   1.724   2.622   1.708

  (Multi)
  3.371   4.690   4.502   4.153   3.651   3.637   3.580   3.854   3.841   3.802

  (Single)
  1.934   2.102   2.246   2.061   1.941   1.900   2.172   2.103   1.911   1.911

运行在一个6核3.7GHz AMD Ryzen 1600机器上。

看起来性能比率仍然大致相同。我想说，除非你真的很难优化，否则就使用多维数组，因为语法更容易使用。

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

如果你使用交错数组和多维数组写一些简单的代码，然后用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也告诉我们，当您使用锯齿数组来分析您的项目时，应该使用锯齿数组而不是多维数组。

使用基于John Leidegren的测试，我使用。net 4.7.2对结果进行了基准测试，这是与我的目的相关的版本，我认为我可以分享。我最初是从dotnet核心GitHub存储库中的这条注释开始的。

随着数组大小的变化，性能似乎有很大变化，至少在我的设置中是这样，1个处理器xeon, 4physical 8logical。

W =初始化一个数组，并将int I * j放入其中。 Wr = do w，然后在另一个循环中设置int x为[i,j]

随着数组大小的增长，多维似乎表现得更好。

更新:最后两个测试用双[，]代替int[，]。考虑到误差，这种差异显得很显著。对于int，锯齿与md的平均比率在1.53x和1.86x之间，对于双精度，它是1.88x和2.42x。

简单地说，多维数组类似于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

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

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

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

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