将 T[] 转换为 T[][] 的最快方法？

So 事实证明并非所有数组都是一样的。多维数组可以具有非零下界。例如，请参阅 Excel PIA 的 Range.Value 属性object[,] rectData = myRange.Value;

我需要将这些数据转换为锯齿状数组。我在下面的第一次尝试有点复杂。有什么优化建议吗？它需要处理下限可能不为零的一般情况。

我有这个前方法：

    public static T[][] AsJagged<T>( this T[,] rect )
    {
        int row1 = rect.GetLowerBound(0);
        int rowN = rect.GetUpperBound(0);
        int col1 = rect.GetLowerBound(1);
        int colN = rect.GetUpperBound(1);

        int height = rowN - row1 + 1;
        int width = colN - col1 + 1;
        T[][] jagged = new T[height][];

        int k = 0;
        int l;
        for ( int i = row1; i < row1 + height; i++ )
        {
            l = 0;
            T[] temp = new T[width];
            for ( int j = col1; j < col1 + width; j++ )
                temp[l++] = rect[i, j];
            jagged[k++] = temp;
        }

        return jagged;
    }

像这样使用：

    public void Foo()
    {
        int[,] iRect1 = { { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 }, { 1, 1, 1, 1 } };
        int[][] iJagged1 = iRect1.AsJagged();

        int[] lengths = { 3, 5 };
        int[] lowerBounds = { 7, 8 };
        int[,] iRect2 = (int[,])Array.CreateInstance(typeof(int), lengths, lowerBounds);
        int[][] iJagged2 = iRect2.AsJagged();

    }

好奇如果Buffer.BlockCopy()会起作用还是更快？

编辑：AsJagged 需要处理引用类型。

编辑：在 AsJagged() 中发现错误。添加int l;并添加了col1 + width到内循环。

前面的视图警告/假设：

• 你似乎只使用int作为您的数据类型（或者至少看起来可以使用Buffer.BlockCopy这意味着您通常可以使用原始类型）。
• 对于您显示的测试数据，我认为使用任何理智的方法不会有太大不同。

话虽如此，以下实现（需要专门针对特定的基元类型（此处为int）因为它使用fixed) 比使用内循环的方法快大约 10 倍：

    unsafe public static int[][] AsJagged2(int[,] rect)
    {
        int row1 = rect.GetLowerBound(0);
        int rowN = rect.GetUpperBound(0);
        int col1 = rect.GetLowerBound(1);
        int colN = rect.GetUpperBound(1);

        int height = rowN - row1 + 1;
        int width = colN - col1 + 1;
        int[][] jagged = new int[height][];

        int k = 0;
        for (int i = row1; i < row1 + height; i++)
        {
            int[] temp = new int[width];

            fixed (int *dest = temp, src = &rect[i, col1])
            {
                MoveMemory(dest, src, rowN * sizeof(int));
            }

            jagged[k++] = temp;
        }

        return jagged;
    }

    [DllImport("kernel32.dll", EntryPoint = "RtlMoveMemory")]
    unsafe internal static extern void MoveMemory(void* dest, void* src, int length);

使用以下“测试代码”：

    static void Main(string[] args)
    {
        Random rand = new Random();
        int[,] data = new int[100,1000];
        for (int i = 0; i < data.GetLength(0); i++)
        {
            for (int j = 0; j < data.GetLength(1); j++)
            {
                data[i, j] = rand.Next(0, 1000);
            }
        }

        Stopwatch sw = Stopwatch.StartNew();

        for (int i = 0; i < 100; i++)
        {
            int[][] dataJagged = AsJagged(data);
        }

        Console.WriteLine("AsJagged:  " + sw.Elapsed);

        sw = Stopwatch.StartNew();

        for (int i = 0; i < 100; i++)
        {
            int[][] dataJagged2 = AsJagged2(data);
        }

        Console.WriteLine("AsJagged2: " + sw.Elapsed);
    }

Where AsJagged（第一种情况）是你的原始函数，我得到以下输出：

AsJagged:  00:00:00.9504376
AsJagged2: 00:00:00.0860492

所以确实有一种更快的方法，然而，根据测试数据的大小、实际执行此操作的次数以及您允许不安全和 P/Invoke 代码的意愿，您可能不需要它.

话虽如此，我们使用的是大型矩阵double（比如 7000x10000 元素）它确实产生了巨大的差异。

更新：关于使用 Buffer.BlockCopy

我可能会忽略一些Marshal或其他技巧，但我不认为使用Buffer.BlockCopy这里是可能的。这是因为它要求源数组和目标数组都是一个Array.

在我们的示例中，目标是一个数组（例如int[] temp = ...）但来源不是。虽然我们“知道”对于原始类型的二维数组，布局是这样的，每个“行”（即第一维）都是内存中类型的数组，但不存在安全的（如unsafe) 获取该数组的方法，而无需先复制它。所以我们基本上需要使用一个只处理内存而不关心它的实际内容的函数 - 就像MoveMemory。顺便说一句，内部实现Buffer.BlockCopy做了类似的事情。