.NET에서 두 배열 병합

.NET에서 두 배열 병합

---

.NET 2.0에는 두 개의 배열을 가져 와서 하나의 배열로 병합하는 기본 제공 기능이 있습니까?

배열은 모두 같은 유형입니다. 코드 배열 내에서 널리 사용되는 함수에서 이러한 배열을 가져오고 데이터를 다른 형식으로 반환하도록 함수를 수정할 수 없습니다.

가능한 경우 이것을 달성하기 위해 내 자신의 함수를 작성하지 않으려 고합니다.

---

배열 중 하나를 조작 할 수 있으면 복사를 수행하기 전에 크기를 조정할 수 있습니다.

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

그렇지 않으면 새로운 배열을 만들 수 있습니다

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

MSDN 볼 수 배열 방법에 대한 자세한 .

---

C # 3.0에서는 LINQ의 Concat 방법을 사용하여이를 쉽게 수행 할 수 있습니다.

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

C # 2.0에는 직접적인 방법이 없지만 Array.Copy가 가장 좋은 솔루션 일 것입니다.

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

이것은 자신의 버전을 쉽게 구현하는 데 사용할 수 있습니다 Concat.

---

LINQ 사용 :

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

중복이 제거됩니다. 중복을 유지하려면 Concat을 사용하십시오.

---

중복을 제거하지 않으려면 다음을 시도하십시오.

LINQ 사용 :

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

---

먼저 "여기에서 실제로 배열을 사용해야합니까?"라는 질문을 스스로에게 확인하십시오.

속도가 가장 중요한 곳에서 무언가를 만들지 않는 한, 형식화 된 목록 List<int>은 아마도 갈 길입니다. 내가 배열을 사용하는 유일한 시간은 네트워크를 통해 물건을 보낼 때 바이트 배열입니다. 그 외에는 절대 만지지 않습니다.

---

LINQ를 사용하는 것이 더 쉬울 것입니다 .

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

먼저 배열을 목록으로 변환하고 병합하십시오 ... 그 후 목록을 배열로 다시 변환하십시오 :)

---

Array.Copy 를 사용할 수 있다고 생각합니다 . 소스 인덱스와 대상 인덱스가 필요하므로 한 배열을 다른 배열에 추가 할 수 있습니다. 단순히 다른 것을 추가하는 것보다 더 복잡해 져야하는 경우에는 이것이 올바른 도구가 아닐 수도 있습니다.

---

대상 배열에 충분한 공간이 있다고 가정하면 Array.Copy()작동합니다. a List<T>와 그 .AddRange()방법을 사용해보십시오 .

---

개인적으로, 나는 빠른 시제품 제작을 위해 마음대로 추가하거나 제거 할 수있는 자체 언어 확장을 선호합니다.

다음은 문자열의 예입니다.

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

LINQ 및 Concat보다 훨씬 빠릅니다. 더 빨리, IEnumerable전달 된 배열의 참조 / 포인터를 저장하고 일반 배열 인 것처럼 전체 컬렉션을 반복 할 수 있는 사용자 지정 유형 래퍼를 사용하고 있습니다. (HPC, 그래픽 처리, 그래픽 렌더링에 유용합니다 ...)

귀하의 코드 :

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

전체 코드 및 제네릭 버전은 https://gist.github.com/lsauer/7919764를 참조하십시오.

참고 : 확장되지 않은 IEnumerable 개체를 반환합니다. 확장 객체를 반환하는 것은 약간 느립니다.

나는 2002 년부터 그러한 확장을 컴파일했으며 CodeProject 및 'Stackoverflow'에 도움이되는 사람들에게 많은 크레딧을 제공했습니다. 나는 이것을 곧 풀어서 여기에 링크를 넣을 것이다.

---

모든 사람들은 이미 자신의 의견을 가지고 있지만 "확장 방법으로 사용"접근 방식보다 더 읽기 쉽다고 생각합니다.

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

그러나 2 개의 배열을 결합 할 때만 사용할 수 있습니다.

---

다른 사람이 두 개의 이미지 바이트 배열을 병합하는 방법을 찾고있는 경우 :

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

---

옵션으로 언급하자면 : 작업중 인 배열이 기본 유형 인 경우-부울 (bool), Char, SByte, Byte, Int16 (short), UInt16, Int32 (int), UInt32, Int64 (long ), UInt64, IntPtr, UIntPtr, Single 또는 Double – Buffer.BlockCopy를 사용해 볼 수 있습니다 . 버퍼 클래스 의 MSDN 페이지에 따르면 :

이 클래스는 System.Array 클래스의 유사한 메소드보다 기본 유형을 조작하는 데 더 나은 성능을 제공합니다 .

@OwenP의 답변 에서 C # 2.0 예제를 시작점으로 사용하면 다음과 같이 작동합니다.

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

There is barely any difference in syntax between Buffer.BlockCopy and the Array.Copy that @OwenP used, but this should be faster (even if only slightly).

---

This is what I came up with. Works for a variable number of 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 }

---

Here is a simple example using Array.CopyTo. I think that it answers your question and gives an example of CopyTo usage - I am always puzzled when I need to use this function because the help is a bit unclear - the index is the position in the destination array where inserting occurs.

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

I guess you can't get it much simpler.

---

I needed a solution to combine an unknown number of arrays.

Surprised nobody else provided a solution using SelectMany with params.

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

If you don't want distinct items just remove distinct.

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

Note: There is definitely no guarantee of ordering when using distinct.

---

I'm assuming you're using your own array types as opposed to the built-in .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;
}

Another way of doing this would be using the built in ArrayList class.

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

Both examples are C#.

---

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

Using the above code two Arrays can be easily merged.

---

Created and extension method to handle 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;
    }
}

---

This code will work for all cases:

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

---

Try this:

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

참고URL : https://stackoverflow.com/questions/59217/merging-two-arrays-in-net