Come concatenare due array in C #?

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

In questo momento lo uso

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

Esiste un metodo più semplice o più efficiente?

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

Prova questo:

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

È possibile scrivere un metodo di estensione:

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

Poi:

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

Ho optato per una soluzione più generica che consente di concatenare una serie arbitraria di matrici unidimensionali dello stesso tipo. (Stavo concatenando 3+ alla volta.)

La mia funzione:

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

E utilizzo:

        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}

Questo è:

using System.Linq;

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

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

È possibile rimuovere la chiamata ToArray () alla fine. C'è un motivo per cui è necessario che sia un array dopo la chiamata a Concat?

La chiamata a Concat crea un iteratore su entrambi gli array. Non crea un nuovo array quindi non hai usato più memoria per un nuovo array. Quando si chiama ToArray, si crea effettivamente un nuovo array e si occupa della memoria per il nuovo array.

Quindi, se hai solo bisogno di iterare facilmente su entrambi, chiama semplicemente Concat.

So che l'OP era solo leggermente incuriosito dalle prestazioni. Quelle più grandi possono avere un risultato diverso (vedi @kurdishTree). E che di solito non importa (@ jordan.peoples). Tuttavia, ero curioso e quindi ho perso la testa (come spiegava @TigerShark) .... Voglio dire che ho scritto un semplice test basato sulla domanda originale .... e tutte le risposte ....

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

}

Il risultato è stato:

Ottieni le tue vittorie.

Stai attento con il Concatmetodo. La concatenazione post array in C # spiega che:

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

Sarà inefficiente per array di grandi dimensioni. Ciò significa che il Concatmetodo è solo per matrici di dimensioni medie (fino a 10000 elementi).

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

Più efficiente (più veloce) da utilizzare Buffer.BlockCopynel corso 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));

Ho scritto un semplice programma di test che "riscalda il jitter", compilato in modalità di rilascio ed eseguito senza un debugger collegato, sulla mia macchina.

Per 10.000.000 di iterazioni dell'esempio nella domanda

Concat ha impiegato 3088ms

CopyTo ha impiegato 1079ms

BlockCopy ha impiegato 603ms

Se modifico gli array di test in due sequenze da 0 a 99, ottengo risultati simili a questo,

Concat ha richiesto 45945ms

CopyTo ha richiesto 2230ms

BlockCopy ha impiegato 1689ms

Da questi risultati posso affermare che i metodi CopyToe BlockCopysono significativamente più efficienti di Concate, inoltre, se le prestazioni sono un obiettivo,BlockCopy hanno un valore superiore CopyTo.

Per mettere in guardia questa risposta, se le prestazioni non contano, o ci saranno poche iterazioni, scegli il metodo che ritieni più semplice. Buffer.BlockCopyoffre alcune utilità per la conversione dei tipi oltre lo scopo di questa domanda.

Risposta in ritardo :-).

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

    }

La struttura più efficiente in termini di RAM (e CPU) per contenere l'array combinato sarebbe una classe speciale che implementa IEnumerable (o se lo desideri deriva anche dall'array) e si collega internamente agli array originali per leggere i valori. AFAIK Concat fa proprio questo.

Nel tuo codice di esempio potresti omettere .ToArray (), il che lo renderebbe più efficiente.

Ci dispiace rivivere un vecchio thread, ma che ne dici di questo:

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

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

Quindi nel tuo codice:

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[]

Fino a quando non chiami .ToArray(), .ToList()o .ToDictionary(...), la memoria non viene allocata, sei libero di "creare la tua query" e chiamare uno di quei tre per eseguirlo o semplicemente esaminarli tutti usando la foreach (var i in z){...}clausola che restituisce un elemento alla volta dalyield return t; sopra...

La funzione sopra può essere trasformata in un'estensione come segue:

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

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

Quindi nel codice, puoi fare qualcosa del tipo:

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[]

Il resto è lo stesso di prima.

Un altro miglioramento per questo sarebbe cambiando T[]in IEnumerable<T>(in modo che il params T[][]diventerebbeparams IEnumerable<T>[] ) per rendere queste funzioni accettano più di un semplice array.

Spero che questo ti aiuti.

Puoi farlo nel modo in cui ti sei riferito, o se vuoi ottenere un manuale veramente su di esso puoi girare il tuo loop:

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

Ho trovato un'elegante soluzione su una riga usando LINQ o Lambda , entrambi funzionano allo stesso modo (LINQ viene convertito in Lambda quando viene compilato il programma). La soluzione funziona per qualsiasi tipo di array e per qualsiasi numero di array.

Utilizzando LINQ:

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

Utilizzando Lambda:

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

Ho fornito entrambe le preferenze. Le soluzioni sagge di prestazioni di @Sergey Shteyn o @ deepee1 sono un po 'più veloci, l'espressione Lambda è la più lenta. Il tempo impiegato dipende dal tipo o dai tipi di elementi dell'array, ma a meno che non vi siano milioni di chiamate, non vi è alcuna differenza significativa tra i metodi.

Quello che devi ricordare è che quando usi LINQ stai utilizzando l'esecuzione ritardata. Gli altri metodi qui descritti funzionano tutti perfettamente, ma vengono eseguiti immediatamente. Inoltre, la funzione Concat () è probabilmente ottimizzata in modi impossibili da eseguire (chiamate verso API interne, chiamate del sistema operativo ecc.). Ad ogni modo, a meno che tu non abbia davvero bisogno di provare e ottimizzare, sei attualmente sulla tua strada verso "la radice di tutti i mali";)

Prova quanto segue:

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

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

Ecco la mia risposta:

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

Questo metodo può essere utilizzato a livello di inizializzazione, ad esempio per definire una concatenazione statica di array statici:

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

Tuttavia, viene fornito con due avvertenze che è necessario considerare:

• Il Concat metodo crea un iteratore su entrambi gli array: non crea un nuovo array, essendo quindi efficiente in termini di memoria utilizzata: tuttavia, il successivo ToArray  annullerà tale vantaggio, poiché in realtà creerà un nuovo array e occuperà la memoria per il nuovo array.
• Come ha detto @Jodrell, Concatsarebbe piuttosto inefficiente per array di grandi dimensioni: dovrebbe essere utilizzato solo per array di medie dimensioni.

Se puntare alle prestazioni è un must, è possibile utilizzare il seguente metodo:

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

Oppure (per i fan di una linea):

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

Sebbene quest'ultimo metodo sia molto più elegante, il primo è decisamente migliore per le prestazioni.

Per ulteriori informazioni, consultare questo post sul mio blog.

Per int [] quello che hai fatto mi sta bene. Anche la risposta di Astander funzionerebbe bene List<int>.

Per array più piccoli <10000 elementi:

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

Penso che la soluzione di cui sopra sia più generale e più leggera delle altre che ho visto qui. È più generale perché non limita la concatenazione per solo due array ed è più leggero perché non utilizza LINQ né List.

Si noti che la soluzione è concisa e la generalità aggiunta non aggiunge un sovraccarico di runtime significativo.

int [] x = new int [] {1, 2, 3}; int [] y = new 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]);
}