İki veya daha fazla bayt dizisini C # ile birleştirmenin en iyi yolu

Ben bir birleştirmek gerekir C # 3 bayt dizilerim var. Bu görevi tamamlamak için en etkili yöntem ne olurdu?

İlkel türler için (bayt dahil) System.Buffer.BlockCopyyerine kullanın System.Array.Copy. O daha hızlı.

Önerilen yöntemlerin her birini, her biri 10 baytlık 3 dizi kullanarak 1 milyon kez yürütülen bir döngüde zamanladım. Sonuçlar burada:

1. Yeni Bayt Dizisi kullanma System.Array.Copy - 0.2187556 saniye
2. Yeni Byte Dizisi kullanarak System.Buffer.BlockCopy - 0.1406286 saniye
3. I # C # verim operatörü kullanılarak sayısız <bayt> - 0.0781270 saniye
4. I LINQ Concat <> - 0.0781270 saniye kullanarak sayısız <bayt>

Her dizinin boyutunu 100 öğeye çıkardım ve testi yeniden çalıştırdım:

1. Yeni Byte Dizisi kullanarak System.Array.Copy - 0.2812554 saniye
2. Yeni Byte Dizisi kullanarak System.Buffer.BlockCopy - 0.2500048 saniye
3. I # C # verim operatörü kullanarak sayısız <bayt> - 0.0625012 saniye
4. LINQ Concat <> ile sayısız <bayt> - 0.0781265 saniye

Her dizinin boyutunu 1000 öğeye çıkardım ve testi yeniden çalıştırdım:

1. Yeni Byte Dizisi System.Array.Copy - 1.0781457 saniye
2. Yeni Byte Dizisi System.Buffer.BlockCopy - 1.0156445 saniye
3. I # C # verim operatörü kullanarak sayısız <bayt> - 0.0625012 saniye
4. LINQ Concat <> ile sayısız <bayt> - 0.0781265 saniye

Son olarak, her dizinin boyutunu 1 milyon elemente artırdım ve testi tekrarladım, her döngüyü sadece 4000 kez yürüttüm:

1. Yeni Byte Dizisi kullanarak System.Array.Copy - 13.4533833 saniye
2. Yeni Byte Array System.Buffer.BlockCopy - - 13.1096267 saniye kullanarak
3. I # C # verim operatörü kullanan <bayt> - 0 saniye
4. IEnumerable <bayt> LINQ Concat <> - 0 saniye kullanarak

Bu nedenle, yeni bir bayt dizisine ihtiyacınız varsa şunu kullanın:

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

Ancak, bir kullanabiliyorsanız IEnumerable<byte>, LINQ'nun Concat <> yöntemini KESİNLİKLE tercih edin. C # verim operatöründen sadece biraz daha yavaştır, ancak daha özlü ve daha zariftir.

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

Rasgele sayıda diziniz varsa ve .NET 3.5 kullanıyorsanız System.Buffer.BlockCopyçözümü şu şekilde daha genel yapabilirsiniz :

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

* Not: Yukarıdaki blok, çalışması için en üstte aşağıdaki ad alanını eklemenizi gerektirir.

using System.Linq;

Jon Skeet'in sonraki veri yapılarının yinelenmesi ile ilgili noktasına (bayt dizisi ile IEnumerable <bayt>), son zamanlama testini (1 milyon öğe, 4000 yineleme) yeniden çalıştırdım ve her bir dizi ile tam dizi üzerinde yinelenen bir döngü ekledim geçmek:

1. Yeni Byte Dizisi kullanarak System.Array.Copy - 78.20550510 saniye
2. Yeni Bayt Dizisi kullanarak System.Buffer.BlockCopy - 77.89261900 saniye
3. I # C # verim operatörü kullanarak sayısız <bayt> - 551.7150161 saniye
4. LINQ Concat <> - 448.1804799 saniye kullanarak sayısız <bayt>

Mesele şu ki, ortaya çıkan veri yapısının hem yaratılmasının hem de kullanımının verimliliğini anlamak ÇOK önemlidir . Sadece yaratılışın verimliliğine odaklanmak, kullanımla ilgili verimsizliği göz ardı edebilir. Kudos, Jon.

Cevapların çoğu bana belirtilen gereklilikleri görmezden geliyor gibi geliyor:

• Sonuç bir bayt dizisi olmalıdır
• Mümkün olduğunca verimli olmalı

Bu ikisi birlikte bir LINQ bayt dizisini göz ardı eder - olan her şey yield, tüm diziyi tekrarlamadan son boyutu elde etmeyi imkansız hale getirecektir.

Bunlar elbette gerçek gereksinimler değilse , LINQ mükemmel bir çözüm (veya IList<T>uygulama) olabilir. Ancak, Superdumbell'in ne istediğini bildiğini varsayacağım.

(DÜZENLEME: Başka bir düşüncem vardı. Dizilerin bir kopyasını oluşturmak ve tembel bir şekilde okumak arasında büyük bir anlamsal fark var. Combine(Veya herhangi bir şeyi çağırdıktan sonra) ) yöntemini kullanabilirsiniz, ancak sonucu kullanmadan önce - tembel değerlendirme ile, bu değişiklik görünür olacaktır. Hemen bir kopya ile, olmayacaktır. Farklı durumlar farklı davranışlar gerektirecektir - sadece farkında olunması gereken bir şey.)

İşte benim önerilen yöntemler - diğer cevapların bazılarında bulunanlara çok benzer, kesinlikle :)

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

Tabii ki "params" sürümü, ilk önce bir dizi bayt dizisi oluşturmayı gerektirir ve bu da ekstra verimsizlik getirir.

Kod temizliği için Matt'in LINQ örneğini bir adım ileri götürdüm:

byte[] rv = a1.Concat(a2).Concat(a3).ToArray();

Benim durumumda, diziler küçük, bu yüzden performansla ilgili değilim.

Yeni bir bayt dizisine ihtiyacınız varsa, aşağıdakileri kullanın:

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

Alternatif olarak, yalnızca tek bir IEnumerable'a ihtiyacınız varsa, C # 2.0 verim operatörünü kullanmayı düşünün:

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'ı kullanmakla ilgili bazı sorunlar yaşadım ... (10 milyondaki dizilerle, aslında çöktü).

Aşağıdakileri basit, kolay ve üzerime çarpmadan yeterince iyi buldum ve HERHANGİ dizi sayısı için çalışıyor (sadece üç değil) (LINQ kullanıyor):

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

Memorystream sınıfı bu işi benim için gayet güzel yapıyor. Arabellek sınıfını bellek akışı kadar hızlı çalıştıramadım.

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

Dizileri birleştirmek için jenerikleri kullanabilir. Aşağıdaki kod kolayca üç diziye genişletilebilir. Bu şekilde, farklı diziler için hiçbir zaman kodu çoğaltmanız gerekmez. Yukarıdaki cevaplardan bazıları benim için aşırı karmaşık görünüyor.

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

@Jon Skeet tarafından verilen cevabın genelleştirilmesi. Temel olarak aynıdır, sadece baytlar için değil, sadece herhangi bir dizi türü için kullanılabilir:

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

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

Bayt Dizileri listesini geçmek için ihtiyacınız olan tek şey bu işlev size Bayt Dizisi (Birleştirilmiş) döndürür. Bu bence en iyi çözüm :).

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 doğru cevaptır, ancak bir nedenden dolayı kilitli bir şey en fazla oyu alıyor. Bu yanıtı beğendiyseniz, belki de bu daha genel çözümü daha da çok istersiniz:

    IEnumerable<byte> Combine(params byte[][] arrays)
    {
        foreach (byte[] a in arrays)
            foreach (byte b in a)
                yield return b;
    }

hangi gibi şeyler yapmanıza izin verir:

    byte[] c = Combine(new byte[] { 0, 1, 2 }, new byte[] { 3, 4, 5 }).ToArray();