Array.Copy 是否适用于多维数组？

Question

这段代码工作正常：

var newArray = new Rectangle[newHeight, newWidth];

for (int x = 0; x < newWidth; x++)
    for (int y = 0; y < newHeight; y++)
        newArray[y, x] = (x >= width) || (y >= height) ? Rectangle.Empty : tiles[y, x];

但我没有太多运气将其替换为 Array.Copy。基本上，如果调整大小的数组更大，它只会在边缘添加空白矩形。如果它较小，那么它应该只切掉边缘。

执行此操作时：

Array.Copy(tiles, newArray, newWidth * newHeight);

它会弄乱数组，其所有内容都会变得无序，并且不会保留其原始索引。也许我只是脑子有病什么的？

Answer 1

是的。然而，它并不像你想象的那样工作。相反，它将每个多维数组视为一个单维数组（这实际上是它们在内存中的样子，这只是一个技巧，让我们在它们之上放置一些结构以将它们视为多维），然后复制单个数组维度结构。因此，如果您有

1 2 3
4 5 6

并且想要将其复制到其中

x x x x
x x x x

，那么它将认为第一个数组为

1 2 3 4 5 6

，第二个数组为

x x x x x x x x

，结果将是

1 2 3 4 5 6 x x

，您将看到“

1 2 3 4
5 6 x x

明白了吗？”

Answer 2

我使用这段代码：

public static void ResizeBidimArrayWithElements<T>(ref T[,] original, int rows, int cols)
{

    T[,] newArray = new T[rows, cols];
    int minX = Math.Min(original.GetLength(0), newArray.GetLength(0));
    int minY = Math.Min(original.GetLength(1), newArray.GetLength(1));

    for (int i = 0; i < minX; ++i)
        Array.Copy(original, i * original.GetLength(1), newArray, i * newArray.GetLength(1), minY);

    original = newArray;

}

像这样调用字符串数组

ResizeBidimArrayWithElements<string>(ref arrayOrigin, vNumRows, vNumCols);

Answer 3

我需要在下一次中断命中之前消耗缓冲区中的数据并复制到大型保存数组。循环复制不是一个选择；太慢了。在完成所有复制之前，我不需要组合数据的多维结构，这意味着我可以 Buffer.BlockCopy() 到一维数组，然后再次复制到多维数组以获得所需的结构。这里有一些代码（在控制台中运行）将演示该技术以及性能。

static class Program
{
    [STAThread]
    static void Main()
    {
        Stopwatch watch = new Stopwatch();

        const int width = 2;
        const int depth = 10 * 1000000;

        //  Create a large array of data
        Random r = new Random(100);
        int[,] data = new int[width, depth];
        for(int i = 0; i < width; i++)
        {
            for(int j = 0; j < depth; j++)
            {
                data[i, j] = r.Next();
            }
        }

        //  Block copy to a single dimension array
        watch.Start();
        int[] buffer = new int[width * depth];
        Buffer.BlockCopy(data, 0, buffer, 0, data.Length * sizeof(int));
        watch.Stop();
        Console.WriteLine("BlockCopy to flat array took {0}", watch.ElapsedMilliseconds);

        //  Block copy to multidimensional array
        int[,] data2 = new int[width, depth];
        watch.Start();
        Buffer.BlockCopy(buffer, 0, data2, 0,buffer.Length * sizeof(int));
        watch.Stop();
        Console.WriteLine("BlockCopy to 2 dimensional array took {0}", watch.ElapsedMilliseconds);


        //  Now try a loop based copy - eck!
        data2 = new int[width, depth];
        watch.Start();
        for (int i = 0; i < width; i++)
        {
            for (int j = 0; j < depth; j++)
            {
                data2[i, j] = data[i, j];
            }
        }
        watch.Stop();
        Console.WriteLine("Loop-copy to 2 dimensional array took {0} ms", watch.ElapsedMilliseconds);
    }
}

输出：

BlockCopy to flat array took 14 ms
BlockCopy to 2 dimensional array took 28 ms
Loop-copy to 2 dimensional array took 149 ms

Answer 4

简单地使用“Clone()”函数，如下所示：

这是您的数组列表

object newArray = new object [row, column];

当您创建另一个数组时，只需使用以下代码：

object[,] clonedArray = (object[,]) newArray.Clone();

简单！玩得开心！