Лучший способ объединить два или более байтовых массивов в C#

многие из ответов, как мне кажется, игнорируют заявленные требования:

• результатом должен быть массив байтов
• он должен быть максимально эффективным

эти два вместе исключают последовательность LINQ байтов-что - нибудь с yield будет невозможно получить окончательный размер без повторения всей последовательности.

если это не реальные требования конечно, LINQ, которая может быть совершенно хорошее решение (или IList<T> реализации). Однако я предполагаю, что Супердумбелл знает, чего он хочет.

(EDIT: у меня только что была другая мысль. Существует большая семантическая разница между копированием массивов и их ленивым чтением. Рассмотрим, что произойдет, если вы измените данные в одном из "Источник" массива после вызова 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" требует сначала создать массив байтовых массивов, что вводит дополнительную неэффективность.

Я взял пример 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, рассмотрите возможность использования оператора yield C# 2.0:

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... (с массивами в 10-миллионном, он фактически разбился).

Я нашел следующее, чтобы быть простым, легким и работает достаточно хорошо без сбоев на меня, и это работает для любого количества массивов (а не только три) (он использует LINQ):

public static byte[] ConcatByteArrays(params byte[][]  arrays)
{
    return arrays.SelectMany(x => x).ToArray();
}

класс memorystream делает эту работу довольно хорошо для меня. Я не мог заставить класс буфера работать так же быстро, как memorystream.

using (MemoryStream ms = new MemoryStream())
{
  ms.Write(BitConverter.GetBytes(22),0,4);
  ms.Write(BitConverter.GetBytes(44),0,4);
  ms.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;
    }

    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();
        }
    }

вот обобщение ответа, предоставленного @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;
}

можно использовать дженерики для объединения массивов. Следующий код может быть легко расширен до трех массивов. Таким образом, вам никогда не нужно дублировать код для различных типов массивов. Некоторые из приведенных выше ответов кажутся мне слишком сложными.

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;
    }

все, что вам нужно передать список байтовых массивов и эта функция вернет вам массив байтов (слили). Это лучшее решение, которое я думаю :).

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();