C# 二维阵列的快速不安全访问

我有一个巨大的二维数组。我需要从中获取元素，但我有一个问题——速度非常慢（我认为这是从编译器中检查索引的问题）。如何以不安全的方式获取数组元素

private byte[][] MY_TASTE_ARRAY;

for (int d = 0; d < MANY_TIMES; d++)
{      
   int a = MY_TASTE_ARRAY[first_index][second_index];
   MakeSomethingWitha(a);
}

private byte[][]我的味觉数组；
for（int d=0；d<多次；d++）
{      
int a=我的味觉数组[第一个索引][第二个索引]；
用a（a）做某事；
}

数组访问速度不慢，我尝试了这个程序，比较了直接或将一组连续循环数从0到255求和的时间，或者将它们放在锯齿状数组或矩阵中：

        const int N = 10000;
        var jagged = new byte[ N ][];
        var matrix = new byte[ N, N ];
        var count = (byte)0;
        for (var i=0; i< N;  i++ )
        {
            jagged[ i ] = new byte[ N ];
            for ( var j = 0; j < N; j++ )
            {
                jagged[ i ][ j ] = count;
                matrix[ i, j ] = count;
                count = count == 255 ? 
                    (byte) 0 : 
                    (byte) ( count + 1 );
            }
        }
        var watch = new Stopwatch();

        watch.Start();
        var total = 0;
        for ( var i = 0; i < N; i++ )
        {
            for ( var j = 0; j < N; j++ )
            {
                total += jagged[ i ][ j ];
            }
        }
        watch.Stop();
        Console.WriteLine( "Total with jagged array: {0} in {1} ms", total, watch.ElapsedMilliseconds );

        watch.Restart();
        total = 0;
        count = (byte)0;
        for ( var i = 0; i < N; i++ )
        {
            for ( var j = 0; j < N; j++ )
            {
                total += matrix[ i, j ];
            }
        }
        watch.Stop();
        Console.WriteLine( "Total with matrix: {0} in {1} ms", total, watch.ElapsedMilliseconds );

        watch.Restart();
        total = 0;
        count = (byte)0;
        for ( var i = 0; i < N; i++ )
        {
            for ( var j = 0; j < N; j++ )
            {
                total += count;
                count = count == 255 ?
                    (byte)0 :
                    (byte)( count + 1 );
            }
        }
        watch.Stop();
        Console.WriteLine( "Total without array: {0} in {1} ms", total, watch.ElapsedMilliseconds );

const int N=10000；
var jagged=新字节[N][]；
var矩阵=新字节[N，N]；
变量计数=（字节）0；
对于（变量i=0；i

---

使用锯齿阵列的结果是497毫秒，使用矩阵的结果是624毫秒，直接计算数字的结果是486毫秒。

我尝试使用列表，但问题仍然存在。非常慢。列表对我来说会更好，但我不明白如何在我的案例1中获得指针。这是一个锯齿状数组（数组数组数组），而不是二维数组（

byte[，]

）。2.你不用猜。使用探查器查找瓶颈。Dmitry，抱歉，它是锯齿状的。但问题仍然存在——当我通过索引删除访问权限时，速度显著提高。通过多处理，您可以同时访问多个元素，这可以提高速度，但如果您试图修改数组或所有进程共享的内容，这不是线程安全的。内存流如何。数据的偏移量可以很容易地计算出来，而且仍然是安全的。OP没有询问使用二维/锯齿阵列是否慢。但是OP有一个X-Y问题。回答OP；你的问题不能真正解决他的问题但是你的回答不能解决任何问题。。这只是对这个问题的一个评论。我想我证明了这个问题在别的地方——因此“解决”了它。希望OP可以试试我的代码，看看他是否得到了类似的性能数字，并与他的实际代码进行比较。这不仅是关于对数组的访问，而且是关于它附近生成的所有代码。如果对向量进行二维数学变换，安全和不安全之间的差异可能会超过x10倍