我在 C# 中有 3 个字节数组，我需要将它们合并为一个。完成这项任务最有效的方法是什么？
【问题讨论】：
Concat方法：IEnumerable<byte> arrays = array1.Concat(array2).Concat(array3);
对于原始类型（包括字节），使用System.Buffer.BlockCopy 而不是System.Array.Copy。它更快。
我使用 3 个每个 10 字节的数组在一个循环中对每个建议的方法进行计时，执行 100 万次。结果如下：
System.Array.Copy 的新字节数组 - 0.2187556 秒System.Buffer.BlockCopy 的新字节数组 - 0.1406286 秒我将每个数组的大小增加到 100 个元素并重新运行测试：
System.Array.Copy 的新字节数组 - 0.2812554 秒System.Buffer.BlockCopy 的新字节数组 - 0.2500048 秒我将每个数组的大小增加到 1000 个元素并重新运行测试：
System.Array.Copy 的新字节数组 - 1.0781457 秒System.Buffer.BlockCopy 的新字节数组 - 1.0156445 秒最后，我将每个数组的大小增加到 100 万个元素并重新运行测试，每个循环只执行 4000 次：
System.Array.Copy 的新字节数组 - 13.4533833 秒System.Buffer.BlockCopy 的新字节数组 - 13.1096267 秒所以，如果你需要一个新的字节数组，使用
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
System.Array.Copy 的新字节数组 - 78.20550510 秒System.Buffer.BlockCopy 的新字节数组 - 77.89261900 秒关键是，了解生成的数据结构的创建和使用的效率非常很重要。仅仅关注创造的效率可能会忽略与使用相关的低效率。致敬，乔恩。
【讨论】：
在我看来，许多答案都忽略了规定的要求：
这两个一起排除了 LINQ 字节序列 - 任何带有 yield 的东西都会使得如果不遍历整个序列就无法获得最终大小。
当然，如果这些不是真正的要求，LINQ 可能是一个非常好的解决方案（或IList<T> 实现）。不过，我假设 Superdumbell 知道他想要什么。
（编辑：我刚刚有了另一个想法。制作数组的副本和懒惰地读取它们之间存在很大的语义差异。考虑一下如果在调用Combine （或其他）方法，但在使用结果之前 - 使用惰性评估，该更改将是可见的。使用即时副本，它不会。不同的情况将需要不同的行为 - 只是需要注意的事情。）
这是我提出的方法 - 当然与其他一些答案中包含的方法非常相似：)
public static byte[] Combine(byte[] first, byte[] second)
{
byte[] ret = new byte[first.Length + second.Length];
Buffer.BlockCopy(first, 0, ret, 0, first.Length);
Buffer.BlockCopy(second, 0, ret, first.Length, second.Length);
return ret;
}
public static byte[] Combine(byte[] first, byte[] second, byte[] third)
{
byte[] ret = new byte[first.Length + second.Length + third.Length];
Buffer.BlockCopy(first, 0, ret, 0, first.Length);
Buffer.BlockCopy(second, 0, ret, first.Length, second.Length);
Buffer.BlockCopy(third, 0, ret, first.Length + second.Length,
third.Length);
return ret;
}
public static byte[] Combine(params byte[][] arrays)
{
byte[] ret = new byte[arrays.Sum(x => x.Length)];
int offset = 0;
foreach (byte[] data in arrays)
{
Buffer.BlockCopy(data, 0, ret, offset, data.Length);
offset += data.Length;
}
return ret;
}
当然，“params”版本需要先创建一个字节数组，这会带来额外的低效率。
【讨论】：
我将 Matt 的 LINQ 示例进一步简化了代码：
byte[] rv = a1.Concat(a2).Concat(a3).ToArray();
就我而言，数组很小，所以我不关心性能。
【讨论】：
如果您只需要一个新的字节数组，请使用以下内容：
byte[] Combine(byte[] a1, byte[] a2, byte[] a3)
{
byte[] ret = new byte[a1.Length + a2.Length + a3.Length];
Array.Copy(a1, 0, ret, 0, a1.Length);
Array.Copy(a2, 0, ret, a1.Length, a2.Length);
Array.Copy(a3, 0, ret, a1.Length + a2.Length, a3.Length);
return ret;
}
或者，如果您只需要一个 IEnumerable，请考虑使用 C# 2.0 yield 运算符：
IEnumerable<byte> Combine(byte[] a1, byte[] a2, byte[] a3)
{
foreach (byte b in a1)
yield return b;
foreach (byte b in a2)
yield return b;
foreach (byte b in a3)
yield return b;
}
【讨论】：
我实际上在使用 Concat 时遇到了一些问题...（有 1000 万个数组，它实际上崩溃了）。
我发现以下内容简单、容易且运行良好且不会让我崩溃，它适用于任意数量的数组（不仅仅是三个）（它使用 LINQ）：
public static byte[] ConcatByteArrays(params byte[][] arrays)
{
return arrays.SelectMany(x => x).ToArray();
}
【讨论】：
memorystream 类对我来说很好地完成了这项工作。我无法让缓冲区类运行得像内存流一样快。
using (MemoryStream ms = new MemoryStream())
{
ms.Write(BitConverter.GetBytes(22),0,4);
ms.Write(BitConverter.GetBytes(44),0,4);
ms.ToArray();
}
【讨论】：
public static byte[] Concat(params byte[][] arrays) {
using (var mem = new MemoryStream(arrays.Sum(a => a.Length))) {
foreach (var array in arrays) {
mem.Write(array, 0, array.Length);
}
return mem.ToArray();
}
}
【讨论】：
public static bool MyConcat<T>(ref T[] base_arr, ref T[] add_arr)
{
try
{
int base_size = base_arr.Length;
int size_T = System.Runtime.InteropServices.Marshal.SizeOf(base_arr[0]);
Array.Resize(ref base_arr, base_size + add_arr.Length);
Buffer.BlockCopy(add_arr, 0, base_arr, base_size * size_T, add_arr.Length * size_T);
}
catch (IndexOutOfRangeException ioor)
{
MessageBox.Show(ioor.Message);
return false;
}
return true;
}
【讨论】：
where T : struct），但是 - 不是 CLR 内部的专家 - 我不能说你是否会在某些情况下遇到异常结构也是如此（例如，如果它们包含引用类型字段）。
可以使用泛型来组合数组。以下代码可以轻松扩展为三个数组。这样，您永远不需要为不同类型的数组复制代码。上面的一些答案对我来说似乎过于复杂。
private static T[] CombineTwoArrays<T>(T[] a1, T[] a2)
{
T[] arrayCombined = new T[a1.Length + a2.Length];
Array.Copy(a1, 0, arrayCombined, 0, a1.Length);
Array.Copy(a2, 0, arrayCombined, a1.Length, a2.Length);
return arrayCombined;
}
【讨论】：
/// <summary>
/// Combine two Arrays with offset and count
/// </summary>
/// <param name="src1"></param>
/// <param name="offset1"></param>
/// <param name="count1"></param>
/// <param name="src2"></param>
/// <param name="offset2"></param>
/// <param name="count2"></param>
/// <returns></returns>
public static T[] Combine<T>(this T[] src1, int offset1, int count1, T[] src2, int offset2, int count2)
=> Enumerable.Range(0, count1 + count2).Select(a => (a < count1) ? src1[offset1 + a] : src2[offset2 + a - count1]).ToArray();
【讨论】：
这是@Jon Skeet 提供的答案的概括。 基本一样，只是对任何类型的数组都可以使用，不仅仅是字节：
public static T[] Combine<T>(T[] first, T[] second)
{
T[] ret = new T[first.Length + second.Length];
Buffer.BlockCopy(first, 0, ret, 0, first.Length);
Buffer.BlockCopy(second, 0, ret, first.Length, second.Length);
return ret;
}
public static T[] Combine<T>(T[] first, T[] second, T[] third)
{
T[] ret = new T[first.Length + second.Length + third.Length];
Buffer.BlockCopy(first, 0, ret, 0, first.Length);
Buffer.BlockCopy(second, 0, ret, first.Length, second.Length);
Buffer.BlockCopy(third, 0, ret, first.Length + second.Length,
third.Length);
return ret;
}
public static T[] Combine<T>(params T[][] arrays)
{
T[] ret = new T[arrays.Sum(x => x.Length)];
int offset = 0;
foreach (T[] data in arrays)
{
Buffer.BlockCopy(data, 0, ret, offset, data.Length);
offset += data.Length;
}
return ret;
}
【讨论】：
sizeof(...) 计算单个元素的大小，然后将其乘以要复制的元素数量，但 sizeof 不能与泛型一起使用类型。可以 - 对于某些类型 - 使用 Marshal.SizeOf(typeof(T))，但某些类型（例如字符串）会出现运行时错误。对 CLR 类型的内部工作有更透彻了解的人将能够在此处指出所有可能的陷阱。可以说[使用 BlockCopy] 编写通用数组连接方法并非易事。
您只需要传递字节数组列表，此函数将返回字节数组（合并）。 这是我认为最好的解决方案:)。
public static byte[] CombineMultipleByteArrays(List<byte[]> lstByteArray)
{
using (var ms = new MemoryStream())
{
using (var doc = new iTextSharp.text.Document())
{
using (var copy = new PdfSmartCopy(doc, ms))
{
doc.Open();
foreach (var p in lstByteArray)
{
using (var reader = new PdfReader(p))
{
copy.AddDocument(reader);
}
}
doc.Close();
}
}
return ms.ToArray();
}
}
【讨论】：
Concat 是正确的答案，但出于某种原因，手动处理的事情获得了最多的选票。如果您喜欢这个答案，也许您会更喜欢这个更通用的解决方案：
IEnumerable<byte> Combine(params byte[][] arrays)
{
foreach (byte[] a in arrays)
foreach (byte b in a)
yield return b;
}
这会让你做这样的事情：
byte[] c = Combine(new byte[] { 0, 1, 2 }, new byte[] { 3, 4, 5 }).ToArray();
【讨论】：