Zusammenführen von zwei Arrays in .NET

Question

Gibt es eine eingebaute Funktion in .NET 2.0, die zwei Arrays nehmen und sie in einem Array zusammenführen?

Die Arrays sind beide vom gleichen Typ. Ich erhalte diese Arrays von einer weit verbreiteten Funktion in meiner Code-Basis und kann nicht die Funktion ändern, um die Daten in einem anderen Format zurückzukehren.

Ich suche meine eigene Funktion zu vermeiden, schreiben, dies zu erreichen, wenn möglich.

Answer 1

Wenn Sie eines des Arrays manipulieren können, können Sie es die Größe, bevor Sie die Kopie ausführen:

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

Sie können aber ein neues Array machen

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

Mehr zu den verfügbaren Array Methoden auf MSDN .

Answer 2

In C # 3.0 Sie LINQ verwenden Concat Methode, dies leicht zu erreichen:

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

In C # 2.0 Sie haben keine solche direkte Art und Weise, aber Array.Copy ist wahrscheinlich die beste Lösung:

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

Dieses leicht verwendet werden könnten Ihre eigene Version von Concat zu implementieren.

Answer 3

Verwenden Sie LINQ :

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

Beachten Sie, diese Duplikate zu entfernen. Wenn Sie Duplikate halten möchten, verwenden Sie Concat.

Answer 4

Wenn Sie nicht wollen, um Duplikate zu entfernen, dann ist diese versuchen

Mit LINQ:

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

Answer 5

Stellen Sie zunächst sicher, dass Sie sich die Frage stellen: „Soll ich wirklich ein Array hier verwenden“?

Es sei denn, man etwas bauen, wo die Geschwindigkeit von größter Bedeutung ist, eine typisierte Liste, wie List<int> ist wahrscheinlich der Weg zu gehen. Das einzige Mal, dass ich Arrays verwenden, sind für Byte-Arrays, wenn Sachen über das Netzwerk gesendet werden. Anders als das ich sie nie berühren.

Answer 6

Einfacher wäre nur unter Verwendung von LINQ :

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

Sie zuerst die Arrays Listen konvertieren und kombiniere sie ... Danach nur die Liste in ein Array umwandeln zurück:)

Answer 7

Ich glaube, Sie können Array.Copy für diese. Es dauert eine Quellenindex und Zielindex so sollten Sie das ein Array an das andere anhängen können. Wenn Sie komplexere gehen müssen, als nur einen zum anderen anhängt, ist dies nicht das richtige Werkzeug für Sie sein kann.

Answer 8

Ziel-Array Unter der Annahme, hat genügend Raum, Array.Copy() arbeiten. Sie könnten auch versuchen, ein List<T> und seine .AddRange() mit Verfahren.

Answer 9

Ich persönlich ziehe meine eigenen Spracherweiterungen, die mich für das Rapid Prototyping nach Belieben hinzufügen oder entfernen.

Es folgt ein Beispiel für Streicher.

//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 ist viel schneller als LINQ und Concat. Schneller noch, ist eine benutzerdefinierte IEnumerable Typ-Wrapper, die Referenzen / Zeiger übergeben Arrays speichert und ermöglicht über die gesamte Sammlung Looping, als ob es ein normales Array waren. (Nützlich bei HPC, Graphics Processing, Graphiken machen ...)

Ihr Code:

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

Für den gesamten Code und eine Generika-Version finden Sie unter: https://gist.github.com/lsauer/ 7919764

Hinweis: Das gibt ein unextended IEnumerable-Objekt. Um wieder ein erweitertes Objekt etwas langsamer ist.

ich seit 2002 solche Erweiterungen zusammengestellt, mit vielen Krediten an hilfreichen Menschen auf Codeproject gehen und ‚Stackoverflow‘. Ich werde diese kurz lösen und den Link setzen hier.

Answer 10

Jeder hat schon zu Wort, aber ich denke, das ist besser lesbar als der „Verwendung als Erweiterungsmethode“ Ansatz:

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

Allerdings kann nur verwendet werden, wenn sie zusammen zwei Arrays zu bringen.

Answer 11

Falls jemand anderes sucht, wie zwei Bild Byte-Arrays verbinden:

        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 12

Nur, um es als Option festgestellt: Wenn die Arrays, mit denen Sie arbeiten, sind von einem primitiven Typ - Boolean (bool), Char, SByte, Byte, Int16 (kurz), UInt16, Int32 (int), UInt32, Int64 (long), UInt64, IntPtr, UIntPtr, Single, oder Doppel - dann könnte man (? oder sollte) versuchen Sie es mit Buffer.BlockCopy . Gemäß der MSDN-Seite für den Buffer Klasse:

  

Diese Klasse bietet eine bessere Leistung für die Manipulation von primitiven Typen als ähnliches Verfahren in der System.Array Klasse.

das C # 2.0 Beispiel für die Verwendung von @ OwenP als Ausgangspunkt beantworten, es würde funktionieren wie folgt:

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

Es gibt kaum einen Unterschied in der Syntax zwischen Buffer.BlockCopy und dem Array.Copy, die verwendet @OwenP, aber das sollte schneller sein (wenn auch nur geringfügig).

Answer 13

Hier ist ein einfaches Beispiel mit Array.CopyTo. Ich denke, dass es Ihre Frage beantwortet und gibt ein Beispiel für CopyTo Nutzung - Ich bin immer verwirrt, wenn ich diese Funktion verwenden muß, weil die Hilfe etwas unklar ist, - der Index die Position im Ziel-Array ist, wo Einfügen auftritt

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

Ich denke, man nicht bekommen kann es viel einfacher.

Answer 14

Ich brauchte eine Lösung, eine unbekannte Anzahl von Arrays zu verbinden.

überrascht sonst niemand eine Lösung mit SelectMany mit params zur Verfügung gestellt.

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

Wenn Sie nicht möchten, dass verschiedene Elemente nur deutliche entfernen.

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

Hinweis: Es gibt definitiv keine Garantie für die Bestellung, wenn verschiedene mit

.

Answer 15

Das ist, was ich kam mit. Arbeitet für eine variable Anzahl von Arrays.

public static T[] ConcatArrays<T>(params T[][] args)
    {
        if (args == null)
            throw new ArgumentNullException();

        var offset = 0;
        var newLength = args.Sum(arr => arr.Length); 
        var newArray = new T[newLength];

        foreach (var arr in args)
        {
            Buffer.BlockCopy(arr, 0, newArray, offset, arr.Length);
            offset += arr.Length;
        }

        return newArray;
    }

...

var header = new byte[] { 0, 1, 2};
var data = new byte[] { 3, 4, 5, 6 };
var checksum = new byte[] {7, 0};
var newArray = ConcatArrays(header, data, checksum);
//output byte[9] { 0, 1, 2, 3, 4, 5, 6, 7, 0 }

Answer 16

Ich gehe davon aus Sie Ihre eigenen Array-Typen verwenden im Gegensatz zu dem integrierten .NET-Arrays:

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

Eine andere Möglichkeit, dies zu tun, würde die in Arraylist-Klasse gebaut werden.

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

Beide Beispiele sind C #.

Answer 17

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

Mit dem obigen Code zwei Arrays können einfach eingebunden werden.

Answer 18

Erstellt und Erweiterungsmethode null zu behandeln

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 19

Dieser Code wird für alle Fälle funktionieren:

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 20

Versuchen Sie folgendes:

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