c# - objects - Fusionando dos arrays en.NET

multidimensional array c#

Question

¿Existe una función incorporada en .NET 2.0 que tome dos arreglos y los combine en un arreglo?

Las matrices son del mismo tipo. Obtengo estos arreglos de una función ampliamente utilizada dentro de mi base de código y no puedo modificar la función para devolver los datos en un formato diferente.

Estoy buscando evitar escribir mi propia función para lograr esto si es posible.

Answer 1

Aquí hay un ejemplo simple usando Array.CopyTo. Creo que responde a su pregunta y da un ejemplo del uso de CopyTo. Siempre me desconcierto cuando necesito usar esta función porque la ayuda no está clara, el índice es la posición en la matriz de destino donde se realiza la inserción.

int[] xSrc1 = new int[3] { 0, 1, 2 };
int[] xSrc2 = new int[5] { 3, 4, 5, 6 , 7 };
int[] xAll = new int[xSrc1.Length + xSrc2.Length];
xSrc1.CopyTo(xAll, 0);
xSrc2.CopyTo(xAll, xSrc1.Length);

Supongo que no puedes hacerlo mucho más simple.

Answer 2

Creado y método de extensión para manejar null.

public static class IEnumerableExtenions
{
public static IEnumerable<T> UnionIfNotNull<T>(this IEnumerable<T> list1, IEnumerable<T> list2)
{
if (list1 != null && list2 != null)
return list1.Union(list2);
else if (list1 != null)
return list1;
else if (list2 != null)
return list2;
else return null;
}
}

Answer 3

Creo que puedes usar Array.Copy para esto. Toma un índice de origen y un índice de destino, por lo que debería poder adjuntar una matriz a la otra. Si necesita ir más complejo que solo añadir uno a otro, puede que esta no sea la herramienta adecuada para usted.

Answer 4

En C # 3.0 puede usar el método Concat de LINQ para lograr esto fácilmente:

int[] front = { 1, 2, 3, 4 };
int[] back = { 5, 6, 7, 8 };
int[] combined = front.Concat(back).ToArray();

En C # 2.0 no tiene una forma tan directa, pero Array.Copy es probablemente la mejor solución:

int[] front = { 1, 2, 3, 4 };
int[] back = { 5, 6, 7, 8 };
int[] combined = new int[front.Length + back.Length];
Array.Copy(front, combined, front.Length);
Array.Copy(back, 0, combined, front.Length, back.Length);

Esto podría usarse fácilmente para implementar su propia versión de Concat .

Answer 5

En caso de que alguien más esté buscando cómo combinar dos matrices de bytes de imágenes:

 private void LoadImage()
{
string src = string.empty;
byte[] mergedImageData = new byte[0];
mergedImageData = MergeTwoImageByteArrays(watermarkByteArray, backgroundImageByteArray);
src = "data:image/png;base64," + Convert.ToBase64String(mergedImageData);
MyImage.ImageUrl = src;
}
private byte[] MergeTwoImageByteArrays(byte[] imageBytes, byte[] imageBaseBytes)
{
byte[] mergedImageData = new byte[0];
using (var msBase = new MemoryStream(imageBaseBytes))
{
System.Drawing.Image imgBase = System.Drawing.Image.FromStream(msBase);
Graphics gBase = Graphics.FromImage(imgBase);
using (var msInfo = new MemoryStream(imageBytes))
{
System.Drawing.Image imgInfo = System.Drawing.Image.FromStream(msInfo);
Graphics gInfo = Graphics.FromImage(imgInfo);
gBase.DrawImage(imgInfo, new Point(0, 0));
//imgBase.Save(Server.MapPath("_____testImg.png"), ImageFormat.Png);
MemoryStream mergedImageStream = new MemoryStream();
imgBase.Save(mergedImageStream, ImageFormat.Png);
mergedImageData = mergedImageStream.ToArray();
mergedImageStream.Close();
}
}
return mergedImageData;
}

Answer 6

Este código funcionará para todos los casos:

int[] a1 ={3,4,5,6};
int[] a2 = {4,7,9};
int i = a1.Length-1;
int j = a2.Length-1;
int resultIndex= i+j+1;
Array.Resize(ref a2, a1.Length +a2.Length);
while(resultIndex >=0)
{
if(i != 0 && j !=0)
{
if(a1[i] > a2[j])
{
a2[resultIndex--] = a[i--];
}
else
{
a2[resultIndex--] = a[j--];
}
}
else if(i>=0 && j<=0)
{
a2[resultIndex--] = a[i--];
}
else if(j>=0 && i <=0)
{
a2[resultIndex--] = a[j--];
}
}

Answer 7

Más fácil sería simplemente usar LINQ :

var array = new string[] { "test" }.ToList();
var array1 = new string[] { "test" }.ToList();
array.AddRange(array1);
var result = array.ToArray();

Primero convierta las matrices a listas y fíjelas ... Después de eso, simplemente vuelva a convertir la lista a una matriz :)

Answer 8

Necesitaba una solución para combinar un número desconocido de matrices.

Sorprendido nadie más proporcionó una solución utilizando SelectMany con params .

 private static T[] Combine<T>(params IEnumerable<T>[] items) =>
items.SelectMany(i => i).Distinct().ToArray();

Si no quieres elementos distintos, simplemente elimina los distintos.

 public string[] Reds = new [] { "Red", "Crimson", "TrafficLightRed" };
public string[] Greens = new [] { "Green", "LimeGreen" };
public string[] Blues = new [] { "Blue", "SkyBlue", "Navy" };
public string[] Colors = Combine(Reds, Greens, Blues);

Nota: Definitivamente no hay garantía de pedido cuando se utiliza distinto.

Answer 9

Personalmente, prefiero mis propias Extensiones de idioma, que agrego o elimino a voluntad para un prototipado rápido.

A continuación se muestra un ejemplo para cadenas.

//resides in IEnumerableStringExtensions.cs
public static class IEnumerableStringExtensions
{
public static IEnumerable<string> Append(this string[] arrayInitial, string[] arrayToAppend)
{
string[] ret = new string[arrayInitial.Length + arrayToAppend.Length];
arrayInitial.CopyTo(ret, 0);
arrayToAppend.CopyTo(ret, arrayInitial.Length);
return ret;
}
}

Es mucho más rápido que LINQ y Concat. Aún más rápido, está usando un IEnumerable tipo IEnumerable personalizado que almacena referencias / punteros de matrices pasadas y permite recorrer toda la colección como si fuera una matriz normal. (Útil en HPC, procesamiento de gráficos, procesamiento de gráficos ...)

Tu codigo:

var someStringArray = new[]{"a", "b", "c"};
var someStringArray2 = new[]{"d", "e", "f"};
someStringArray.Append(someStringArray2 ); //contains a,b,c,d,e,f

Para ver el código completo y una versión genérica, consulte: https://gist.github.com/lsauer/7919764

Nota: Esto devuelve un objeto IEnumerable no extendido. Para devolver un objeto extendido es un poco más lento.

Compilé dichas extensiones desde 2002, y muchos créditos se destinaron a personas útiles en CodeProject y ''''. Los lanzaré en breve y pondré el enlace aquí.

Answer 10

Primero, asegúrate de hacerte la pregunta "¿Realmente debería estar usando una matriz aquí"?

A menos que esté construyendo algo donde la velocidad sea lo más importante, una lista escrita, como List<int> es probablemente el camino a seguir. La única vez que utilizo matrices son para matrices de bytes al enviar cosas a través de la red. Aparte de eso, nunca los toco.

Answer 11

Prueba esto:

ArrayLIst al = new ArrayList();
al.AddRange(array_1);
al.AddRange(array_2);
al.AddRange(array_3);
array_4 = al.ToArray();

Answer 12

Si no desea eliminar duplicados, intente esto

Utilice LINQ:

var arr1 = new[] { 1, 2, 3, 4, 5 };
var arr2 = new[] { 6, 7, 8, 9, 0 };
var arr = arr1.Concat(arr2).ToArray();

Answer 13

Si puede manipular una de las matrices, puede cambiar su tamaño antes de realizar la copia:

T[] array1 = getOneArray();
T[] array2 = getAnotherArray();
int array1OriginalLength = array1.Length;
Array.Resize<T>(ref array1, array1OriginalLength + array2.Length);
Array.Copy(array2, 0, array1, array1OriginalLength, array2.Length);

De lo contrario, puedes hacer una nueva matriz.

T[] array1 = getOneArray();
T[] array2 = getAnotherArray();
T[] newArray = new T[array1.Length + array2.Length];
Array.Copy(array1, newArray, array1.Length);
Array.Copy(array2, 0, newArray, array1.Length, array2.Length);

Más sobre métodos de Array disponibles en MSDN .

Answer 14

Solo para tenerlo como una opción: si los arrays con los que está trabajando son de tipo primitivo: Boolean (bool), Char, SByte, Byte, Int16 (corto), UInt16, Int32 (int), UInt32, Int64 (largo) ), UInt64, IntPtr, UIntPtr, Single o Double - ¿entonces podría (o debería?) Intentar usar Buffer.BlockCopy . Según la página de MSDN para la clase Buffer :

Esta clase proporciona un mejor rendimiento para manipular tipos primitivos que métodos similares en la clase System.Array .

Utilizando el ejemplo de C # 2.0 de la answer de @ OwenP como punto de partida, funcionaría de la siguiente manera:

int[] front = { 1, 2, 3, 4 };
int[] back = { 5, 6, 7, 8 };
int[] combined = new int[front.Length + back.Length];
Buffer.BlockCopy(front, 0, combined, 0, front.Length);
Buffer.BlockCopy(back, 0, combined, front.Length, back.Length);

Apenas hay diferencias en la sintaxis entre Buffer.BlockCopy y Array.Copy que se usó en @OwenP, pero esto debería ser más rápido (aunque sea solo un poco).

Answer 15

Supongo que está utilizando sus propios tipos de matriz en lugar de las matrices .NET integradas:

public string[] merge(input1, input2)
{
string[] output = new string[input1.length + input2.length];
for(int i = 0; i < output.length; i++)
{
if (i >= input1.length)
output[i] = input2[i-input1.length];
else
output[i] = input1[i];
}
return output;
}

Otra forma de hacerlo sería utilizando la clase ArrayList integrada.

public ArrayList merge(input1, input2)
{
Arraylist output = new ArrayList();
foreach(string val in input1)
output.add(val);
foreach(string val in input2)
output.add(val);
return output;
}

Ambos ejemplos son C #.

Answer 16

Suponiendo que la matriz de destino tenga suficiente espacio, Array.Copy() funcionará. También puede intentar usar una List<T> y su método .AddRange() .

Answer 17

Todos ya han expresado su opinión, pero creo que es más legible que el enfoque del "uso como método de extensión":

var arr1 = new[] { 1, 2, 3, 4, 5 };
var arr2 = new[] { 6, 7, 8, 9, 0 };
var arr = Queryable.Concat(arr1, arr2).ToArray();

Sin embargo, solo se puede utilizar cuando se juntan 2 matrices.

Answer 18

Utilice LINQ :

var arr1 = new[] { 1, 2, 3, 4, 5 };
var arr2 = new[] { 6, 7, 8, 9, 0 };
var arr = arr1.Union(arr2).ToArray();

Answer 19

int [] SouceArray1 = new int[] {2,1,3};
int [] SourceArray2 = new int[] {4,5,6};
int [] targetArray = new int [SouceArray1.Length + SourceArray2.Length];
SouceArray1.CopyTo(targetArray,0);
SourceArray2.CopyTo(targetArray,SouceArray1.Length) ;
foreach (int i in targetArray) Console.WriteLine(i + " "); 

Usando el código anterior, dos matrices se pueden combinar fácilmente.