有更快的方法在C＃中复制数组吗？

使用Buffer.BlockCopy。它的全部目的是快速执行（请参见Buffer）：

与System.Array类中的类似方法相比，此类提供了更好的操作原始类型的性能。

诚然，我还没有做过任何基准测试，但这就是文档。它也适用于多维数组。只需确保始终指定要复制的 字节数 ，而不是指定多少 个
元素，并且确保您正在处理原始数组。

另外，我还没有对此进行测试，但是如果将委托绑定到并直接调用它，则 可能会使
系统的性能降低

System.Buffer.memcpyimpl

internal static unsafe void memcpyimpl(byte* src, byte* dest, int len)

它确实需要指针，但是我相信它已针对可能的最高速度进行了优化，因此，即使您手头有组装，我也认为没有任何方法可以使速度更快。

更新 ：

由于要求（并满足我的好奇心），我对此进行了测试：

using System;using System.Diagnostics;using System.Reflection;unsafe delegate void MemCpyImpl(byte* src, byte* dest, int len);static class Temp{    //There really should be a generic CreateDelegate<T>() method... -___-    static MemCpyImpl memcpyimpl = (MemCpyImpl)Delegate.CreateDelegate(        typeof(MemCpyImpl), typeof(Buffer).GetMethod("memcpyimpl", BindingFlags.Static | BindingFlags.NonPublic));    const int COUNT = 32, SIZE = 32 << 20;    //Use different buffers to help avoid CPU cache effects    static byte[]        aSource = new byte[SIZE], aTarget = new byte[SIZE],        bSource = new byte[SIZE], bTarget = new byte[SIZE],        cSource = new byte[SIZE], cTarget = new byte[SIZE];    static unsafe void TestUnsafe()    {        Stopwatch sw = Stopwatch.StartNew();        fixed (byte* pSrc = aSource)        fixed (byte* pDest = aTarget) for (int i = 0; i < COUNT; i++)     memcpyimpl(pSrc, pDest, SIZE);        sw.Stop();        Console.WriteLine("Buffer.memcpyimpl: {0:N0} ticks", sw.ElapsedTicks);    }    static void TestBlockCopy()    {        Stopwatch sw = Stopwatch.StartNew();        sw.Start();        for (int i = 0; i < COUNT; i++) Buffer.BlockCopy(bSource, 0, bTarget, 0, SIZE);        sw.Stop();        Console.WriteLine("Buffer.BlockCopy: {0:N0} ticks", sw.ElapsedTicks);    }    static void TestArrayCopy()    {        Stopwatch sw = Stopwatch.StartNew();        sw.Start();        for (int i = 0; i < COUNT; i++) Array.Copy(cSource, 0, cTarget, 0, SIZE);        sw.Stop();        Console.WriteLine("Array.Copy: {0:N0} ticks", sw.ElapsedTicks);    }    static void Main(string[] args)    {        for (int i = 0; i < 10; i++)        { TestArrayCopy(); TestBlockCopy(); TestUnsafe(); Console.WriteLine();        }    }}

结果：

Buffer.BlockCopy: 469,151 ticksArray.Copy: 469,972 ticksBuffer.memcpyimpl: 496,541 ticksBuffer.BlockCopy: 421,011 ticksArray.Copy: 430,694 ticksBuffer.memcpyimpl: 410,933 ticksBuffer.BlockCopy: 425,112 ticksArray.Copy: 420,839 ticksBuffer.memcpyimpl: 411,520 ticksBuffer.BlockCopy: 424,329 ticksArray.Copy: 420,288 ticksBuffer.memcpyimpl: 405,598 ticksBuffer.BlockCopy: 422,410 ticksArray.Copy: 427,826 ticksBuffer.memcpyimpl: 414,394 ticks

现在更改顺序：

Array.Copy: 419,750 ticksBuffer.memcpyimpl: 408,919 ticksBuffer.BlockCopy: 419,774 ticksArray.Copy: 430,529 ticksBuffer.memcpyimpl: 412,148 ticksBuffer.BlockCopy: 424,900 ticksArray.Copy: 424,706 ticksBuffer.memcpyimpl: 427,861 ticksBuffer.BlockCopy: 421,929 ticksArray.Copy: 420,556 ticksBuffer.memcpyimpl: 421,541 ticksBuffer.BlockCopy: 436,430 ticksArray.Copy: 435,297 ticksBuffer.memcpyimpl: 432,505 ticksBuffer.BlockCopy: 441,493 ticks

现在再次更改顺序：

Buffer.memcpyimpl: 430,874 ticksBuffer.BlockCopy: 429,730 ticksArray.Copy: 432,746 ticksBuffer.memcpyimpl: 415,943 ticksBuffer.BlockCopy: 423,809 ticksArray.Copy: 428,703 ticksBuffer.memcpyimpl: 421,270 ticksBuffer.BlockCopy: 428,262 ticksArray.Copy: 434,940 ticksBuffer.memcpyimpl: 423,506 ticksBuffer.BlockCopy: 427,220 ticksArray.Copy: 431,606 ticksBuffer.memcpyimpl: 422,900 ticksBuffer.BlockCopy: 439,280 ticksArray.Copy: 432,649 ticks

或者换句话说：他们很有竞争力；一般而言，

memcpyimpl