Array.Copy vs Buffer.BlockCopy

On .NET 5.0.6 (x64) - for copying byte array to byte array - Array.Copy seems to be the winner even for short arrays. Interestingly enough Enumumerable.Concat is also relatively fast on longer arrays because it optimizes for ICollection<T> if enumerable implements it (it is not the case for .NET Framework though).

Benchmark results and source code:

public class ArrayConcatBenchmark
{
    [Params(50, 100, 1000, 10000)]
    public int ArrayLength;

    [Params(1, 2, 3)]
    public int NumberOfArrays;

    private byte[][] data;

    [GlobalSetup]
    public void GlobalSetup()
    {
        data = new byte[NumberOfArrays][];
        var random = new Random(42);
        for (int i = 0; i < NumberOfArrays; i++)
        {
            data[i] = new byte[ArrayLength];
            random.NextBytes(data[i]);
        }
    }

    [Benchmark]
    public byte[] EnumerableConcat()
    {
        IEnumerable<byte> enumerable = data[0];

        for (int n = 1; n < NumberOfArrays; n++)
        {
            enumerable = enumerable.Concat(data[n]);
        }

        return enumerable.ToArray();
    }

    [Benchmark]
    public byte[] ForLoop()
    {
        var result = new byte[ArrayLength * NumberOfArrays];

        for (int n = 0; n < NumberOfArrays; n++)
        {
            for (int i = 0; i < ArrayLength; i++)
            {
                result[i + n * ArrayLength] = data[n][i];
            }
        }

        return result;
    }

    [Benchmark]
    public byte[] ForeachLoop()
    {
        var result = new byte[ArrayLength * NumberOfArrays];

        for (int n = 0; n < NumberOfArrays; n++)
        {
            int i = 0;

            foreach (var item in data[n])
            {
                result[i + n * ArrayLength] = item;
                i++;
            }
        }

        return result;
    }

    [Benchmark]
    public byte[] ArrayCopy()
    {
        var result = new byte[ArrayLength * NumberOfArrays];

        for (int n = 0; n < NumberOfArrays; n++)
        {
            Array.Copy(data[n], 0, result, n * ArrayLength, ArrayLength);
        }

        return result;
    }

    [Benchmark]
    public byte[] BufferBlockCopy()
    {
        var result = new byte[ArrayLength * NumberOfArrays];

        for (int n = 0; n < NumberOfArrays; n++)
        {
            Buffer.BlockCopy(data[n], 0, result, n * ArrayLength, ArrayLength);
        }

        return result;
    }

    public static void Main(string[] args)
    {
        //Console.WriteLine("Are all results the same: " + AreAllResultsTheSame());
        BenchmarkRunner.Run<ArrayConcatBenchmark>();
    }

    private static bool AreAllResultsTheSame()
    {
        var ac = new ArrayConcatBenchmark()
        {
            NumberOfArrays = 2,
            ArrayLength = 100,
        };

        ac.GlobalSetup();

        var firstResult = ac.EnumerableConcat();
        var otherResults = new[]
        {
            ac.ForLoop(),
            ac.ForeachLoop(),
            ac.ArrayCopy(),
            ac.BufferBlockCopy(),
        };

        return otherResults.All(x => firstResult.SequenceEqual(x));
    }
}