Array.Copy与Buffer.BlockCopy

Array.Copy和 Buffer.BlockCopy都做同样的事情，但是BlockCopy目标是快速字节级原始数组复制，而这Copy是通用的实现。我的问题是-在什么情况下应该使用BlockCopy？在复制原始类型数组时，应该在任何时候使用它，还是仅在为性能而编码时才使用它？使用Buffer.BlockCopyover 有天生的危险Array.Copy吗？

由于要Buffer.BlockCopy基于参数的参数是基于字节的，而不是基于索引的Array.Copy，因此与使用相比，您更有可能搞乱代码，因此我只会Buffer.BlockCopy在代码的性能至关重要的部分中使用。

序幕

我参加晚会很晚，但是有32,000次观看，值得做对这一点。到目前为止，已发布答案中的大多数微基准测试代码都存在一个或多个严重的技术缺陷，包括没有将内存分配移出测试循环（这会引入严重的GC工件），未测试变量与确定性执行流，JIT预热，而不跟踪测试内的变异性。另外，大多数答案都没有测试缓冲区大小和原始类型（对于32位或64位系统）的影响。为了更全面地解决这个问题，我将其连接到我开发的自定义微基准测试框架中，该框架可以尽可能地减少大多数常见的“陷阱”。测试是在32位计算机和64位计算机上均以.NET 4.0 Release模式运行的。在20个测试运行中平均得到结果，其中每个运行每种方法有100万次测试。测试的原始类型为byte（1个字节），int（4个字节）和double（8个字节）。测试了三种方法：Array.Copy()，Buffer.BlockCopy()和循环中的简单按索引分配。数据量太大，无法在此处发布，因此我将总结要点。

外卖

• 如果您的缓冲区长度约为75-100或更短，则显式循环复制例程通常比在32位和64位计算机上测试的所有3种原始类型中的任何一种Array.Copy()或Buffer.BlockCopy()全部都快（约5％）。另外，与这两种选择相比，显式循环复制例程的性能差异明显较低。几乎可以肯定，良好的性能归因于CPU L1 / L2 / L3内存缓存利用的引用局部性以及无方法调用开销。
  • 仅对于32位计算机上的double缓冲区：对于测试到100k以下的所有缓冲区大小，显式循环复制例程都优于这两种选择。与其他方法相比，改进幅度为3-5％。这是因为性能和变得完全时使本机32比特宽度降解。因此，我假设相同的效果也适用于缓冲区。Array.Copy()Buffer.BlockCopy()long
• 对于超过约100的缓冲区，显式循环复制的速度将比其他两种方法慢得多（只有一种特殊的例外情况刚刚提到）。两者之间的差异最为明显byte[]，在大缓冲区大小下，显式循环复制的速度可能会慢7倍或更多。
• 通常，对于所有3种原始类型进行测试，并在所有缓冲区大小中进行测试，Array.Copy()并且Buffer.BlockCopy()执行几乎相同。平均而言，Array.Copy()虽然Buffer.BlockCopy()偶尔会击败它，但似乎只占用了大约2％或更短时间的极微优势（但通常会提高0.2％-0.5％）。由于未知原因，Buffer.BlockCopy()测试内变异性明显高于Array.Copy()。尽管我尝试了多种缓解措施，但对原因却没有可操作的理论，但无法消除这种影响。
• 因为它Array.Copy()是一种“更智能”，更通用且更安全的方法，除了速度稍快且平均变异性较小外，Buffer.BlockCopy()在几乎所有常见情况下均应优先使用该方法。唯一Buffer.BlockCopy()显着更好的用例是当源数组和目标数组的值类型不同时（如Ken Smith的答案所指出）。虽然这种情况并不常见，Array.Copy()但与的直接转换相比，由于连续的“安全”值类型转换，此处的效果可能会很差Buffer.BlockCopy()。
• 在此处可以找到来自StackOverflow外部的其他证据，该证据Array.Copy()比Buffer.BlockCopy()同类型数组复制的速度更快。

另一个使用有意义的示例Buffer.BlockCopy()是，当您提供了一组原语（例如，短裤），并且需要将其转换为字节数组（例如，用于通过网络传输）时。在处理Silverlight AudioSink的音频时，我经常使用此方法。它以short[]数组的形式提供样本，但是byte[]在构建提交给的数据包时需要将其转换为数组Socket.SendAsync()。您可以使用BitConverter，并一次又一次地遍历数组，但是这样做要快得多（在我的测试中约为20倍）：

Buffer.BlockCopy(shortSamples, 0, packetBytes, 0, shortSamples.Length * sizeof(short)).  

同样的技巧也可以反向使用：

Buffer.BlockCopy(packetBytes, readPosition, shortSamples, 0, payloadLength);

这与您在安全的C＃中接近(void *)C和C ++中常见的那种内存管理差不多。

根据我的测试，性能并不是理由要比Array.Copy更喜欢Buffer.BlockCopy。在我的测试中，Array.Copy实际上比Buffer.BlockCopy 快。

var buffer = File.ReadAllBytes(...);

var length = buffer.Length;
var copy = new byte[length];

var stopwatch = new Stopwatch();

TimeSpan blockCopyTotal = TimeSpan.Zero, arrayCopyTotal = TimeSpan.Zero;

const int times = 20;

for (int i = 0; i < times; ++i)
{
    stopwatch.Start();
    Buffer.BlockCopy(buffer, 0, copy, 0, length);
    stopwatch.Stop();

    blockCopyTotal += stopwatch.Elapsed;

    stopwatch.Reset();

    stopwatch.Start();
    Array.Copy(buffer, 0, copy, 0, length);
    stopwatch.Stop();

    arrayCopyTotal += stopwatch.Elapsed;

    stopwatch.Reset();
}

Console.WriteLine("bufferLength: {0}", length);
Console.WriteLine("BlockCopy: {0}", blockCopyTotal);
Console.WriteLine("ArrayCopy: {0}", arrayCopyTotal);
Console.WriteLine("BlockCopy (average): {0}", TimeSpan.FromMilliseconds(blockCopyTotal.TotalMilliseconds / times));
Console.WriteLine("ArrayCopy (average): {0}", TimeSpan.FromMilliseconds(arrayCopyTotal.TotalMilliseconds / times));

示例输出：

bufferLength: 396011520
BlockCopy: 00:00:02.0441855
ArrayCopy: 00:00:01.8876299
BlockCopy (average): 00:00:00.1020000
ArrayCopy (average): 00:00:00.0940000

ArrayCopy比BlockCopy聪明。它说明了如果源和目标是同一数组，如何复制元素。

如果我们用0、1、2、3、4填充int数组并应用：

Array.Copy（array，0，array，1，array.Length-1）;

我们最终得到预期的0,0,1,2,3。

用BlockCopy尝试一下，我们得到：0,0,2,3,4。如果我array[0]=-1在那之后赋值，它会按预期变为-1,0,2,3,4，但是如果数组长度是偶数（如6），我们将得到-1,256,2,3,4,5。危险的东西。除了将一个字节数组复制到另一个字节数组之外，不要使用BlockCopy。

在另一种情况下，您只能使用Array.Copy：如果数组大小大于2 ^ 31。Array.Copy具有带有longsize参数的重载。BlockCopy没有那个。

要权衡这一论点，如果不注意他们如何编写此基准，很容易被误导。我写了一个非常简单的测试来说明这一点。在下面的测试中，如果我在先启动Buffer.BlockCopy或Array.Copy之间交换测试顺序，则最先执行的顺序几乎总是最慢的（尽管接近）。这意味着出于种种原因，我不会简单地多次运行测试，尤其是一次又一次地运行测试，而不会给出准确的结果。

我采取的措施是按1000000次尝试对1000000个连续双打数组进行每次维护。但是，然后我忽略了前900000个周期，并对其余的取平均值。在这种情况下，缓冲区是优越的。

private static void BenchmarkArrayCopies()
        {
            long[] bufferRes = new long[1000000];
            long[] arrayCopyRes = new long[1000000];
            long[] manualCopyRes = new long[1000000];

            double[] src = Enumerable.Range(0, 1000000).Select(x => (double)x).ToArray();

            for (int i = 0; i < 1000000; i++)
            {
                bufferRes[i] = ArrayCopyTests.ArrayBufferBlockCopy(src).Ticks;
            }

            for (int i = 0; i < 1000000; i++)
            {
                arrayCopyRes[i] = ArrayCopyTests.ArrayCopy(src).Ticks;
            }

            for (int i = 0; i < 1000000; i++)
            {
                manualCopyRes[i] = ArrayCopyTests.ArrayManualCopy(src).Ticks;
            }

            Console.WriteLine("Loop Copy: {0}", manualCopyRes.Average());
            Console.WriteLine("Array.Copy Copy: {0}", arrayCopyRes.Average());
            Console.WriteLine("Buffer.BlockCopy Copy: {0}", bufferRes.Average());

            //more accurate results - average last 1000

            Console.WriteLine();
            Console.WriteLine("----More accurate comparisons----");

            Console.WriteLine("Loop Copy: {0}", manualCopyRes.Where((l, i) => i > 900000).ToList().Average());
            Console.WriteLine("Array.Copy Copy: {0}", arrayCopyRes.Where((l, i) => i > 900000).ToList().Average());
            Console.WriteLine("Buffer.BlockCopy Copy: {0}", bufferRes.Where((l, i) => i > 900000).ToList().Average());
            Console.ReadLine();
        }

public class ArrayCopyTests
    {
        private const int byteSize = sizeof(double);

        public static TimeSpan ArrayBufferBlockCopy(double[] original)
        {
            Stopwatch watch = new Stopwatch();
            double[] copy = new double[original.Length];
            watch.Start();
            Buffer.BlockCopy(original, 0 * byteSize, copy, 0 * byteSize, original.Length * byteSize);
            watch.Stop();
            return watch.Elapsed;
        }

        public static TimeSpan ArrayCopy(double[] original)
        {
            Stopwatch watch = new Stopwatch();
            double[] copy = new double[original.Length];
            watch.Start();
            Array.Copy(original, 0, copy, 0, original.Length);
            watch.Stop();
            return watch.Elapsed;
        }

        public static TimeSpan ArrayManualCopy(double[] original)
        {
            Stopwatch watch = new Stopwatch();
            double[] copy = new double[original.Length];
            watch.Start();
            for (int i = 0; i < original.Length; i++)
            {
                copy[i] = original[i];
            }
            watch.Stop();
            return watch.Elapsed;
        }
    }

https://github.com/chivandikwa/Random-Benchmarks

只是想添加我的测试用例，它再次显示BlockCopy与Array.Copy相比没有“性能”优势。它们在我的机器上的释放模式下似乎具有相同的性能（复制5000万个整数都花费大约66ms）。在调试模式下，BlockCopy仅快一点。

    private static T[] CopyArray<T>(T[] a) where T:struct 
    {
        T[] res = new T[a.Length];
        int size = Marshal.SizeOf(typeof(T));
        DateTime time1 = DateTime.Now;
        Buffer.BlockCopy(a,0,res,0, size*a.Length);
        Console.WriteLine("Using Buffer blockcopy: {0}", (DateTime.Now - time1).Milliseconds);
        return res;
    }

    static void Main(string[] args)
    {
        int simulation_number = 50000000;
        int[] testarray1 = new int[simulation_number];

        int begin = 0;
        Random r = new Random();
        while (begin != simulation_number)
        {
            testarray1[begin++] = r.Next(0, 10000);
        }

        var copiedarray = CopyArray(testarray1);

        var testarray2 = new int[testarray1.Length];
        DateTime time2 = DateTime.Now;
        Array.Copy(testarray1, testarray2, testarray1.Length);
        Console.WriteLine("Using Array.Copy(): {0}", (DateTime.Now - time2).Milliseconds);
    }