C # 'de iki diziyi nasıl birleştirebilirim?

int[] x = new int [] { 1, 2, 3};
int[] y = new int [] { 4, 5 };

int[] z = // your answer here...

Debug.Assert(z.SequenceEqual(new int[] { 1, 2, 3, 4, 5 }));

Şu an kullanıyorum

int[] z = x.Concat(y).ToArray();

Daha kolay veya daha verimli bir yöntem var mı?

var z = new int[x.Length + y.Length];
x.CopyTo(z, 0);
y.CopyTo(z, x.Length);

Bunu dene:

List<int> list = new List<int>();
list.AddRange(x);
list.AddRange(y);
int[] z = list.ToArray();

Bir uzantı yöntemi yazabilirsiniz:

public static T[] Concat<T>(this T[] x, T[] y)
{
    if (x == null) throw new ArgumentNullException("x");
    if (y == null) throw new ArgumentNullException("y");
    int oldLen = x.Length;
    Array.Resize<T>(ref x, x.Length + y.Length);
    Array.Copy(y, 0, x, oldLen, y.Length);
    return x;
}

Sonra:

int[] x = {1,2,3}, y = {4,5};
int[] z = x.Concat(y); // {1,2,3,4,5}

Aynı türden bir boyutlu tek boyutlu dizileri birleştirmeyi sağlayan daha genel amaçlı bir çözüme karar verdim. (Bir seferde 3+ bitiştiriyordum.)

Benim fonksiyonum:

    public static T[] ConcatArrays<T>(params T[][] list)
    {
        var result = new T[list.Sum(a => a.Length)];
        int offset = 0;
        for (int x = 0; x < list.Length; x++)
        {
            list[x].CopyTo(result, offset);
            offset += list[x].Length;
        }
        return result;
    }

Ve kullanım:

        int[] a = new int[] { 1, 2, 3 };
        int[] b = new int[] { 4, 5, 6 };
        int[] c = new int[] { 7, 8 };
        var y = ConcatArrays(a, b, c); //Results in int[] {1,2,3,4,5,6,7,8}

Budur:

using System.Linq;

int[] array1 = { 1, 3, 5 };
int[] array2 = { 0, 2, 4 };

// Concatenate array1 and array2.
var result1 = array1.Concat(array2);

ToArray () çağrısını sonlandırabilirsiniz. Concat çağrısından sonra bir dizi olması için bir neden var mı?

Concat çağrıldığında her iki dizide de yineleyici oluşturulur. Yeni bir dizi oluşturmaz, bu nedenle yeni bir dizi için daha fazla bellek kullanmazsınız. ToArray'ı çağırdığınızda aslında yeni bir dizi oluşturur ve yeni dizi için belleği alırsınız.

Yani her ikisini de kolayca tekrarlamanız gerekiyorsa Concat'ı arayın.

OP'nin performans hakkında sadece hafifçe merak ettiğini biliyorum. Daha büyük diziler farklı bir sonuç alabilir (bkz. @KurdishTree). Ve genellikle önemli değil (@ jordan.peoples). Hiçbiri daha az, ben merak vardı ve bu nedenle (@TigerShark açıklayan gibi) aklımı kaybetti .... Yani orijinal soru .... ve tüm cevapları dayalı basit bir test yazdım ....

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace concat
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] x = new int [] { 1, 2, 3};
            int[] y = new int [] { 4, 5 };


            int itter = 50000;
            Console.WriteLine("test iterations: {0}", itter);

            DateTime startTest = DateTime.Now;
            for(int  i = 0; i < itter; i++)
            {
                int[] z;
                z = x.Concat(y).ToArray();
            }
            Console.WriteLine ("Concat Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks );

            startTest = DateTime.Now;
            for(int  i = 0; i < itter; i++)
            {
                var vz = new int[x.Length + y.Length];
                x.CopyTo(vz, 0);
                y.CopyTo(vz, x.Length);
            }
            Console.WriteLine ("CopyTo Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks );

            startTest = DateTime.Now;
            for(int  i = 0; i < itter; i++)
            {
                List<int> list = new List<int>();
                list.AddRange(x);
                list.AddRange(y);
                int[] z = list.ToArray();
            }
            Console.WriteLine("list.AddRange Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                int[] z = Methods.Concat(x, y);
            }
            Console.WriteLine("Concat(x, y) Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                int[] z = Methods.ConcatArrays(x, y);
            }
            Console.WriteLine("ConcatArrays Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                int[] z = Methods.SSConcat(x, y);
            }
            Console.WriteLine("SSConcat Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int k = 0; k < itter; k++)
            {
                int[] three = new int[x.Length + y.Length];

                int idx = 0;

                for (int i = 0; i < x.Length; i++)
                    three[idx++] = x[i];
                for (int j = 0; j < y.Length; j++)
                    three[idx++] = y[j];
            }
            Console.WriteLine("Roll your own Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);


            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                int[] z = Methods.ConcatArraysLinq(x, y);
            }
            Console.WriteLine("ConcatArraysLinq Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                int[] z = Methods.ConcatArraysLambda(x, y);
            }
            Console.WriteLine("ConcatArraysLambda Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                List<int> targetList = new List<int>(x);
                targetList.Concat(y);
            }
            Console.WriteLine("targetList.Concat(y) Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);

            startTest = DateTime.Now;
            for (int i = 0; i < itter; i++)
            {
                int[] result = x.ToList().Concat(y.ToList()).ToArray();
            }
            Console.WriteLine("x.ToList().Concat(y.ToList()).ToArray() Test Time in ticks: {0}", (DateTime.Now - startTest).Ticks);
        }
    }
    static class Methods
    {
        public static T[] Concat<T>(this T[] x, T[] y)
        {
            if (x == null) throw new ArgumentNullException("x");
            if (y == null) throw new ArgumentNullException("y");
            int oldLen = x.Length;
            Array.Resize<T>(ref x, x.Length + y.Length);
            Array.Copy(y, 0, x, oldLen, y.Length);
            return x;
        }

        public static T[] ConcatArrays<T>(params T[][] list)
        {
            var result = new T[list.Sum(a => a.Length)];
            int offset = 0;
            for (int x = 0; x < list.Length; x++)
            {
                list[x].CopyTo(result, offset);
                offset += list[x].Length;
            }
            return result;
        }


        public static T[] SSConcat<T>(this T[] first, params T[][] arrays)
        {
            int length = first.Length;
            foreach (T[] array in arrays)
            {
                length += array.Length;
            }
            T[] result = new T[length];
            length = first.Length;
            Array.Copy(first, 0, result, 0, first.Length);
            foreach (T[] array in arrays)
            {
                Array.Copy(array, 0, result, length, array.Length);
                length += array.Length;
            }
            return result;
        }

        public static T[] ConcatArraysLinq<T>(params T[][] arrays)
        {
            return (from array in arrays
                    from arr in array
                    select arr).ToArray();
        }

        public static T[] ConcatArraysLambda<T>(params T[][] arrays)
        {
            return arrays.SelectMany(array => array.Select(arr => arr)).ToArray();
        }
    }

}

Sonuç şuydu:

Kendi kazançlarınızı yuvarlayın.

ConcatYönteme dikkat edin . Sonrası C # Dizi Birleştirme açıklar:

var z = x.Concat(y).ToArray();

Büyük diziler için verimsiz olacaktır. Bu, Concatyöntemin yalnızca meduim boyutlu diziler (10000 öğeye kadar) için olduğu anlamına gelir .

public static T[] Concat<T>(this T[] first, params T[][] arrays)
{
    int length = first.Length;
    foreach (T[] array in arrays)
    {
        length += array.Length;
    }
    T[] result = new T[length];
    length = first.Length;
    Array.Copy(first, 0, result, 0, first.Length);
    foreach (T[] array in arrays)
    {
        Array.Copy(array, 0, result, length, array.Length);
        length += array.Length;
    }
    return result;
}

Kullanmak (daha hızlı) Daha verimli Buffer.BlockCopyüzerinde Array.CopyTo,

int[] x = new int [] { 1, 2, 3};
int[] y = new int [] { 4, 5 };

int[] z = new int[x.Length + y.Length];
var byteIndex = x.Length * sizeof(int);
Buffer.BlockCopy(x, 0, z, 0, byteIndex);
Buffer.BlockCopy(y, 0, z, byteIndex, y.Length * sizeof(int));

Makinemde "Jitter'ı ısıtan", serbest bırakma modunda derlenen ve hata ayıklayıcı olmadan çalıştırılan basit bir test programı yazdım.

Söz konusu örneğin 10.000.000 yinelemesi için

Concat 3088ms aldı

CopyTo 1079ms aldı

BlockCopy 603ms aldı

Test dizilerini 0'dan 99'a kadar iki diziye değiştirirsem buna benzer sonuçlar alırım,

Concat aldı 45945 ms

CopyTo 2230ms aldı

BlockCopy 1689 ms sürdü

Bu sonuçlardan, CopyTove BlockCopyyöntemlerinin çok daha verimli olduğunu Concatve ayrıca performansın bir hedef BlockCopyolması durumunda değerinin üzerinde olduğunu söyleyebilirim CopyTo.

Bu cevabı uyarmak için, performans önemli değilse veya çok az yineleme olacaksa, en kolay bulduğunuz yöntemi seçin. Buffer.BlockCopybu sorunun kapsamı dışında tip dönüşümü için bazı yararlar sunar.

Geç cevap :-).

public static class ArrayExtention
    {

        public static T[] Concatenate<T>(this T[] array1, T[] array2)
        {
            T[] result = new T[array1.Length + array2.Length];
            array1.CopyTo(result, 0);
            array2.CopyTo(result, array1.Length);
            return result;
        }

    }

Birleştirilmiş diziyi tutmak için RAM (ve CPU) açısından en verimli yapı, IEnumerable uygulayan (veya Diziden türetmek istiyorsanız) ve değerleri okumak için orijinal dizilere dahili olarak bağlanan özel bir sınıf olacaktır. AFAIK Concat tam da bunu yapıyor.

Örnek kodunuzda .ToArray () yöntemini atlayabilirsiniz, bu da onu daha verimli hale getirir.

Eski bir diziyi canlandırdığım için üzgünüm, ama buna ne dersiniz:

static IEnumerable<T> Merge<T>(params T[][] arrays)
{
    var merged = arrays.SelectMany(arr => arr);

    foreach (var t in merged)
        yield return t;
}

Sonra kodunuzda:

int[] x={1, 2, 3};
int[] y={4, 5, 6};

var z=Merge(x, y);  // 'z' is IEnumerable<T>

var za=z.ToArray(); // 'za' is int[]

Aradığınızda kadar .ToArray(), .ToList()ya da .ToDictionary(...), bellek tahsis edilmez, bunu gerçekleştirmenin ve bu üç ya çağrı birini "Sorgunuzu" veya basitçe kullanarak hepsini geçmesi özgürdürler foreach (var i in z){...}bir defada bir öğe döndüren maddesiniyield return t; yukarıda ...

Yukarıdaki fonksiyon aşağıdaki gibi bir uzantıya dönüştürülebilir:

static IEnumerable<T> Merge<T>(this T[] array1, T[] array2)
{
    var merged = array1.Concat(array2);

    foreach (var t in merged)
        yield return t;
}

Yani kodda, şöyle bir şey yapabilirsiniz:

int[] x1={1, 2, 3};
int[] x2={4, 5, 6};
int[] x3={7, 8};

var z=x1.Merge(x2).Merge(x3);   // 'z' is IEnumerable<T>

var za=z.ToArray(); // 'za' is int[]

Gerisi eskisi gibi.

Bunun bir diğer gelişme değiştirerek olacaktır T[]içine IEnumerable<T>öylesine ( params T[][]olacaktıparams IEnumerable<T>[] bu işlevler daha adil diziler daha kabul etmesini sağlamak için).

Bu yardımcı olur umarım.

Referansta bulunduğunuz şekilde yapabilirsiniz veya gerçekten manuel olarak almak istiyorsanız kendi döngünüzü döndürebilirsiniz:

        string[] one = new string[] { "a", "b" };
        string[] two = new string[] { "c", "d" };
        string[] three;

        three = new string[one.Length + two.Length];

        int idx = 0;

        for (int i = 0; i < one.Length; i++)
            three[idx++] = one[i];
        for (int j = 0; j < two.Length; j++)
            three[idx++] = two[j];

Kullanarak zarif bir satır çözüm buldum LINQ veya Lambda ifadesini , her ikisi de aynı şekilde çalışır (program derlendiğinde LINQ Lambda'ya dönüştürülür). Çözüm, herhangi bir dizi türü ve herhangi bir dizi dizi için çalışır.

LINQ kullanma:

public static T[] ConcatArraysLinq<T>(params T[][] arrays)
{
    return (from array in arrays
            from arr in array
            select arr).ToArray();
}

Lambda kullanma:

public static T[] ConcatArraysLambda<T>(params T[][] arrays)
{
    return arrays.SelectMany(array => array.Select(arr => arr)).ToArray();
}

Her ikisini de tercih ettim. Performans açısından @Sergey Shteyn'in veya @ deepee1'in çözümleri biraz daha hızlıdır, Lambda ifadesi en yavaştır. Zaman, dizi elemanlarının türüne bağlıdır, ancak milyonlarca çağrı olmadığı sürece yöntemler arasında önemli bir fark yoktur.

Hatırlamanız gereken şey, LINQ kullanırken gecikmeli yürütme kullandığınızdır. Burada açıklanan diğer yöntemlerin hepsi mükemmel çalışır, ancak hemen uygulanır. Ayrıca Concat () işlevi muhtemelen kendi kendinize yapamayacağınız şekilde optimize edilmiştir (dahili API'lere çağrılar, işletim sistemi çağrıları vb.). Her neyse, gerçekten denemeniz ve optimize etmeniz gerekmedikçe, şu anda "tüm kötülüklerin kökü" yolundasınız;)

Takip etmeyi dene:

T[] r1 = new T[size1];
T[] r2 = new T[size2];

List<T> targetList = new List<T>(r1);
targetList.Concat(r2);
T[] targetArray = targetList.ToArray();

İşte cevabım:

int[] z = new List<string>()
    .Concat(a)
    .Concat(b)
    .Concat(c)
    .ToArray();

Bu yöntem, başlatma seviyesinde, örneğin statik dizilerin statik bir birleşimini tanımlamak için kullanılabilir:

public static int[] a = new int [] { 1, 2, 3, 4, 5 };
public static int[] b = new int [] { 6, 7, 8 };
public static int[] c = new int [] { 9, 10 };

public static int[] z = new List<string>()
    .Concat(a)
    .Concat(b)
    .Concat(c)
    .ToArray();

Ancak, dikkate almanız gereken iki uyarı ile birlikte gelir:

• Concat Yöntem, her iki dizide fazla bir yineleyici oluşturur: takip eden ancak: bu bellek açısından verimli olan, böylece, kullanılan yeni bir dizi oluşturmaz ToArray  aslında yeni bir dizi oluşturmak ve için bellek kaplar vereceği için avantaj inkâr edecek yeni dizi.
• @Jodrell'in söylediği gibi, Concatbüyük diziler için oldukça verimsiz olacaktır: yalnızca orta boyutlu diziler için kullanılmalıdır.

Performansı hedeflemek şartsa, bunun yerine aşağıdaki yöntem kullanılabilir:

/// <summary>
/// Concatenates two or more arrays into a single one.
/// </summary>
public static T[] Concat<T>(params T[][] arrays)
{
    // return (from array in arrays from arr in array select arr).ToArray();

    var result = new T[arrays.Sum(a => a.Length)];
    int offset = 0;
    for (int x = 0; x < arrays.Length; x++)
    {
        arrays[x].CopyTo(result, offset);
        offset += arrays[x].Length;
    }
    return result;
}

Veya (tek gömlekli hayranlar için):

int[] z = (from arrays in new[] { a, b, c } from arr in arrays select arr).ToArray();

İkinci yöntem çok daha zarif olmasına rağmen, birincisi performans için kesinlikle daha iyidir.

Ek bilgi için lütfen blogumdaki bu gönderiye bakın .

İnt [] için yaptıklarım bana iyi geliyor. saldırganın cevabı da işe yarayacaktır List<int>.

Daha küçük diziler için <10000 eleman:

using System.Linq;

int firstArray = {5,4,2};
int secondArray = {3,2,1};

int[] result = firstArray.ToList().Concat(secondArray.ToList()).toArray();

static class Extensions
{
    public static T[] Concat<T>(this T[] array1, params T[] array2) => ConcatArray(array1, array2);

    public static T[] ConcatArray<T>(params T[][] arrays)
    {
        int l, i;

        for (l = i = 0; i < arrays.Length; l += arrays[i].Length, i++);

        var a = new T[l];

        for (l = i = 0; i < arrays.Length; l += arrays[i].Length, i++)
            arrays[i].CopyTo(a, l);

        return a;
    }
}

Yukarıdaki çözümün burada gördüğüm diğerlerinden daha genel ve daha hafif olduğunu düşünüyorum. Daha geneldir çünkü sadece iki dizinin birleştirmesini sınırlamaz ve LINQ veya List kullanmadığı için daha açıktır.

Çözümün özlü olduğunu ve eklenen genelliğin önemli çalışma zamanı yükü eklemediğini unutmayın.

int [] x = yeni int [] {1, 2, 3}; int [] y = yeni int [] {4, 5};

int [] z = x.Union (y) .ToArray ();

int[] scores = { 100, 90, 90, 80, 75, 60 };
int[] alice = { 50, 65, 77, 90, 102 };
int[] scoreBoard = new int[scores.Length + alice.Length];

int j = 0;
for (int i=0;i<(scores.Length+alice.Length);i++)  // to combine two arrays
{
    if(i<scores.Length)
    {
        scoreBoard[i] = scores[i];
    }
    else
    {
        scoreBoard[i] = alice[j];
        j = j + 1;

    }
}


for (int l = 0; l < (scores.Length + alice.Length); l++)
{
    Console.WriteLine(scoreBoard[l]);
}