¿Cómo concateno dos matrices en 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 }));

Ahora mismo uso

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

¿Existe un método más fácil o más eficiente?

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

Prueba esto:

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

Podrías escribir un método de extensión:

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

Luego:

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

Me decidí por una solución de uso más general que permite concatenar un conjunto arbitrario de matrices unidimensionales del mismo tipo. (Estaba concatenando 3+ a la vez).

Mi funcion:

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

Y uso:

        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}

Eso es todo:

using System.Linq;

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

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

Puede quitar la llamada ToArray () al final. ¿Hay alguna razón por la que necesita que sea una matriz después de la llamada a Concat?

Llamar a Concat crea un iterador sobre ambas matrices. No crea una nueva matriz, por lo que no ha utilizado más memoria para una nueva matriz. Cuando llama a ToArray, en realidad crea una nueva matriz y ocupa la memoria de la nueva matriz.

Entonces, si solo necesita iterar fácilmente sobre ambos, simplemente llame a Concat.

Sé que el OP solo tenía un poco de curiosidad sobre el rendimiento. Que las matrices más grandes pueden obtener un resultado diferente (ver @kurdishTree). Y eso generalmente no importa (@ jordan.peoples). Sin embargo, tenía curiosidad y, por lo tanto, perdí la cabeza (como explicaba @TigerShark) ... quiero decir que escribí una prueba simple basada en la pregunta original ... y todas las respuestas ...

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

}

El resultado fue:

Tira tus propias victorias.

Ten cuidado con el Concatmétodo. La Concatenación de matriz posterior en C # explica que:

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

Será ineficiente para grandes matrices. Eso significa que el Concatmétodo es solo para matrices de tamaño mediano (hasta 10000 elementos).

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

Más eficiente (más rápido) para utilizar Buffer.BlockCopysobre 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));

Escribí un programa de prueba simple que "calienta el Jitter", compilado en modo de lanzamiento y lo ejecuté sin un depurador conectado, en mi máquina.

Para 10,000,000 iteraciones del ejemplo en la pregunta

Concat tomó 3088 ms

CopyTo tardó 1079ms

BlockCopy tardó 603 ms

Si modifico las matrices de prueba a dos secuencias de 0 a 99, obtengo resultados similares a este,

Concat tomó 45945 ms

CopyTo tardó 2230 ms

BlockCopy tardó 1689ms

A partir de estos resultados, puedo afirmar que los métodos CopyToy BlockCopyson significativamente más eficientes Concaty, además, si el rendimiento es un objetivo, BlockCopytiene valor sobreCopyTo .

Para advertir esta respuesta, si el rendimiento no importa, o habrá pocas iteraciones, elija el método que le resulte más fácil. Buffer.BlockCopyofrece alguna utilidad para la conversión de tipos más allá del alcance de esta pregunta.

Respuesta tardía :-).

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 estructura más eficiente en términos de RAM (y CPU) para mantener la matriz combinada sería una clase especial que implemente IEnumerable (o si lo desea, incluso se deriva de Array) y se vincula internamente a las matrices originales para leer los valores. AFAIK Concat hace exactamente eso.

Sin embargo, en su código de muestra podría omitir .ToArray (), lo que lo haría más eficiente.

Lamento revivir un hilo viejo, pero ¿qué tal esto?

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

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

Luego en tu código:

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

Hasta que llame .ToArray(), .ToList()o .ToDictionary(...)la memoria no esté asignada, tiene la libertad de "construir su consulta" y llamar a uno de esos tres para ejecutarla o simplemente revisarlos todos utilizando la foreach (var i in z){...}cláusula que devuelve un elemento a la vezyield return t; encima...

La función anterior se puede convertir en una extensión de la siguiente manera:

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

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

Entonces, en el código, puede hacer algo como:

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

El resto es igual que antes.

Otra mejora a esto sería cambiar T[]a IEnumerable<T>(por lo que params T[][]se convertiría enparams IEnumerable<T>[] ) para hacer estas funciones aceptan más de matrices sólo.

Espero que esto ayude.

Puede hacerlo de la forma en que se ha referido, o si desea obtener un manual realmente al respecto, puede rodar su propio bucle:

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

He encontrado una solución elegante de una línea usando LINQ o expresión Lambda , ambas funcionan igual (LINQ se convierte a Lambda cuando se compila el programa). La solución funciona para cualquier tipo de matriz y para cualquier número de matrices.

Usando LINQ:

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

Usando Lambda:

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

He proporcionado ambos para la preferencia de uno. Las soluciones de @Sergey Shteyn o @ deepee1 en cuanto al rendimiento son un poco más rápidas, siendo la expresión de Lambda la más lenta. El tiempo necesario depende del tipo o tipos de elementos de la matriz, pero a menos que haya millones de llamadas, no hay una diferencia significativa entre los métodos.

Lo que debe recordar es que cuando usa LINQ está utilizando una ejecución retrasada. Los otros métodos descritos aquí funcionan perfectamente, pero se ejecutan de inmediato. Además, la función Concat () probablemente está optimizada de formas que no puede hacer usted mismo (llamadas a API internas, llamadas al sistema operativo, etc.). De todos modos, a menos que realmente necesites probar y optimizar, actualmente estás en tu camino hacia "la raíz de todo mal";)

Intenta lo siguiente:

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

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

Aquí está mi respuesta:

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

Este método se puede utilizar en el nivel de inicialización, por ejemplo, para definir una concatenación estática de matrices estáticas:

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

Sin embargo, viene con dos advertencias que debe tener en cuenta:

• El Concat método crea un iterador sobre ambas matrices: no crea una nueva matriz, por lo tanto, es eficiente en términos de memoria utilizada: sin embargo, la posterior  ToArray  negará dicha ventaja, ya que en realidad creará una nueva matriz y ocupará la memoria para el nueva matriz
• Como dijo @Jodrell, Concatsería bastante ineficiente para matrices grandes: solo debería usarse para matrices medianas.

Si el objetivo es lograr el rendimiento, se puede utilizar el siguiente método:

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

O (para fanáticos de una sola línea):

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

Aunque el último método es mucho más elegante, el primero definitivamente es mejor para el rendimiento.

Para obtener información adicional, consulte esta publicación en mi blog.

Para int [] lo que has hecho me parece bien. La respuesta de Astander también funcionaría bien List<int>.

Para matrices más pequeñas <10000 elementos:

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

Creo que la solución anterior es más general y más ligera que las otras que vi aquí. Es más general porque no limita la concatenación para solo dos matrices y es más ligero porque no usa LINQ ni List.

Tenga en cuenta que la solución es concisa y la generalidad agregada no agrega una sobrecarga de tiempo de ejecución significativa.

int [] x = nuevo 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]);
}