Слияние двух массивов в .NET

Question

Есть ли в .NET 2.0 встроенная функция, которая будет принимать два массива и объединять их в один массив?

Массивы имеют одинаковый тип. Я получаю эти массивы из широко используемой функции в моей базе кода и не могу изменить функцию, чтобы она возвращала данные в другом формате.

Я стараюсь не писать свою собственную функцию для достижения этой цели, если это возможно.

Answer 1

В 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.

Answer 2

Если вы можете управлять одним из массивов, вы можете изменить его размер перед выполнением копирования:

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 .

Answer 3

Использование LINQ :

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

Имейте в виду, это удалит дубликаты. Если вы хотите сохранить дубликаты, используйте Concat.

Answer 4

Если вы не хотите удалять дубликаты, попробуйте это

Использовать 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

Во-первых, убедитесь, что вы задаете себе вопрос «Должен ли я действительно использовать массив здесь»?

Если вы не создаете что-то, где скорость имеет первостепенное значение, вероятно, вам следует использовать печатный список типа List<int>. Единственный раз, когда я использую массивы, это байтовые массивы при отправке данных по сети. Кроме этого, я никогда не прикасаюсь к ним.

Answer 6

Проще просто использовать LINQ :

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

Сначала преобразуйте массивы в списки и объедините их ... После этого просто преобразуйте список обратно в массив:)

Answer 7

Я думаю, что вы можете использовать Array.Copy для этого. Он принимает исходный индекс и целевой индекс, поэтому вы можете добавить один массив к другому. Если вам нужно выполнить более сложную задачу, чем просто добавить одно к другому, это может оказаться не подходящим инструментом для вас.

Answer 8

Если в массиве назначения достаточно места, Array.Copy() будет работать. Вы также можете попробовать использовать List<T> и метод .AddRange().

Answer 9

Каждый уже высказал свое мнение, но я думаю, что это более читабельно, чем подход «использовать как расширение»:

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

Однако его можно использовать только при объединении 2 массивов.

Answer 10

Лично я предпочитаю свои собственные языковые расширения, которые я добавляю или удаляю по желанию для быстрого создания прототипов.

Ниже приведен пример для строк.

//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 Type-оболочка, которая хранит ссылки / указатели переданных массивов и позволяет циклически перемещаться по всей коллекции, как если бы это был обычный массив. (Полезно в 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. Я скоро выпущу их и выложу здесь ссылку.