对于基本类型（包括字节），请使用System.Buffer.BlockCopy代替System.Array.Copy。它更快。

我对每个建议的方法进行了计时，分别使用3个10字节的数组，执行了100万次循环。结果如下：

1. 新的字节数组使用System.Array.Copy -0.2187556秒
2. 新的字节数组使用System.Buffer.BlockCopy -0.1406286秒
3. 使用C＃yield操作符的IEnumerable -0.0781270秒
4. 使用LINQ的Concat <>的IEnumerable -0.0781270秒

我将每个数组的大小增加到100个元素，然后重新运行测试：

1. 新字节数组使用System.Array.Copy -0.2812554秒
2. 新的字节数组使用System.Buffer.BlockCopy -0.2500048秒
3. 使用C＃收益运算符的IEnumerable -0.0625012秒
4. 使用LINQ的Concat <>的IEnumerable -0.0781265秒

我将每个数组的大小增加到1000个元素，然后重新运行测试：

1. 使用System.Array.Copy -1.0781457秒的新字节数组
2. 使用System.Buffer.BlockCopy -1.0156445秒的新字节数组
3. 使用C＃收益运算符的IEnumerable -0.0625012秒
4. 使用LINQ的Concat <>的IEnumerable -0.0781265秒

最后，我将每个数组的大小增加到一百万个元素，然后重新运行测试，每个循环 仅 执行4000次：

1. 新的字节数组使用System.Array.Copy -13.4533833秒
2. 新的字节数组使用System.Buffer.BlockCopy -13.1096267秒
3. 使用C＃yield运算符的IEnumerable -0秒
4. 使用LINQ的Concat <>的IEnumerable -0秒

因此，如果您需要一个新的字节数组，请使用

byte[] rv = new byte[a1.Length + a2.Length + a3.Length];
System.Buffer.BlockCopy(a1, 0, rv, 0, a1.Length);
System.Buffer.BlockCopy(a2, 0, rv, a1.Length, a2.Length);
System.Buffer.BlockCopy(a3, 0, rv, a1.Length + a2.Length, a3.Length);

但是，如果可以使用IEnumerable<byte>，则 肯定会 首选LINQ的Concat
<>方法。它仅比C＃yield运算符稍慢，但更简洁，更优雅。

IEnumerable<byte> rv = a1.Concat(a2).Concat(a3);

如果您具有任意数量的数组，并且正在使用.NET 3.5，则可以使System.Buffer.BlockCopy解决方案更加通用，如下所示：

private byte[] Combine(params byte[][] arrays)
{
    byte[] rv = new byte[arrays.Sum(a => a.Length)];
    int offset = 0;
    foreach (byte[] array in arrays) {
        System.Buffer.BlockCopy(array, 0, rv, offset, array.Length);
        offset += array.Length;
    }
    return rv;
}

*注意：上面的代码块要求您在顶部添加以下名称空间才能起作用。

using System.Linq;

就Jon Skeet关于后续数据结构的迭代（字节数组与IEnumerable
）的观点而言，我重新运行了最后的时序测试（100万个元素，进行4000次迭代），并添加了一个循环，每次循环遍历整个数组通过：

1. 新的字节数组使用System.Array.Copy -78.20550510秒
2. 新的字节数组使用System.Buffer.BlockCopy -77.89261900秒
3. 使用C＃yield操作符的IEnumerable -551.7150161秒
4. 使用LINQ的Concat <>的IEnumerable -448.1804799秒

关键是，了解创建数据结构的效率 和使用 结果的结构 非常 重要。仅关注创作的效率可能会忽略与使用相关的效率低下。乔恩·库德斯 __