c#将多个数组复制/合并为一个数组的更好方法

是否有更好的方法将多个阵列复制到单个阵列中，有谁能提供建议？生成的数组必须具有相同顺序的元素，例如先是

arrayOne

值，然后是

arraySecond

值，等等

下面是我目前正在执行的一个模型，它能像预期的那样工作。正在寻找一种更聪明的方法

// Initialise the first array.
string[] arrayOne = new string[5];
arrayOne[0] = "arrayOneValue[0]";
arrayOne[1] = "arrayOneValue[1]";
arrayOne[2] = "arrayOneValue[2]";
arrayOne[3] = "arrayOneValue[3]";
arrayOne[4] = "arrayOneValue[4]";

// Initialise the second array.
string[] arrayTwo = new string[6];
arrayTwo[0] = "arrayTwoValue[0]";
arrayTwo[1] = "arrayTwoValue[1]";
arrayTwo[2] = "arrayTwoValue[2]";
arrayTwo[3] = "arrayTwoValue[3]";
arrayTwo[4] = "arrayTwoValue[4]";
arrayTwo[5] = "arrayTwoValue[5]";

// Initialise the third array.
string[] arrayThree = new string[3];
arrayThree[0] = "arrayThreeValue[0]";
arrayThree[1] = "arrayThreeValue[1]";
arrayThree[2] = "arrayThreeValue[2]";

// string[] arrayN = new string[n]
//.
//.
//.

// Initialise the target array.
string[] finalArray = new string[arrayOne.Length + arrayTwo.Length + arrayThree.Length];
// ArrayN - string[] finalArray = new string[arrayOne.Length + arrayTwo.Length + arrayThree.Length + arrayN.Length];

// Copy/merge the three arrays into the target array.
Array.Copy(arrayOne, 0, finalArray, 0, arrayOne.Length);
Array.Copy(arrayTwo, 0, finalArray, arrayOne.Length, arrayTwo.Length);
Array.Copy(arrayThree, 0, finalArray, (arrayOne.Length + arrayTwo.Length), arrayThree.Length);
//.
//.
//.
//.
// ArrayN - Array.Copy(arrayN, 0, finalArray, (arrayOne.Length + arrayTwo.Length + arrayN), arrayN.Length) ?;

正如您所看到的，arrayN的代码可能会变得更长。我最多有5个阵列要复制到一个阵列中，因此，它是可管理的。我将此技术作为WebAPI的一部分使用，在WebAPI中，oracle参数对象的集合根据要传递给多个oracle存储过程的业务规则进行整合。这里的任何建议都将不胜感激。提前谢谢。 结果

---

您只需使用LINQ，无需手动处理阵列长度和偏移：

var finalArray = arrayOne.Concat(arrayTwo).Concat(arrayThree).ToArray();

---

它的性能可能比使用

Array.Copy

稍差一些，但这段代码更具可读性、可维护性和错误安全性，这一点更为重要

您可以将输入数组放在一个集合中并对其进行迭代。我之所以提到这一点，是因为这可能比使用LINQ更有效。这取决于你处理的数据，但可能还不足以产生影响

在下面的代码中，在我的机器上，LINQ在调用数组时需要9000-13000个滴答声（一个滴答声=100 ns）。复制是~500个滴答声

publicstaticvoidbenchmark1（）
{
var arr1=可枚举的.Range（110000）.ToArray（）；
var arr2=可枚举的.Range（1000120000）.ToArray（）；
var arr3=可枚举的.Range（2000130000）.ToArray（）；
var arr4=可枚举的.Range（3000140000）.ToArray（）；
var sw=Stopwatch.StartNew（）；
var result=arr1.Concat（arr2.Concat（arr3.Concat（arr4.ToArray））；
sw.Stop（）；
Console.WriteLine（$“Elpased ticks:{sw.ElapsedTicks}”）；
}
公共静态void基准2（）
{
var arr1=可枚举的.Range（110000）.ToArray（）；
var arr2=可枚举的.Range（1000120000）.ToArray（）；
var arr3=可枚举的.Range（2000130000）.ToArray（）；
var arr4=可枚举的.Range（3000140000）.ToArray（）；
var arrays=new List（）{arr1，arr2，arr3，arr4}；
var sw=Stopwatch.StartNew（）；
int finalLen=0；
foreach（数组中的var arr）
{
最终长度+=阵列长度；
}
var结果=新整数[最终值]；
int currentPosition=0；
foreach（数组中的var arr）
{
Array.Copy（arr，0，result，currentPosition，arr.Length）；
当前位置+=阵列长度；
}
sw.Stop（）；
Console.WriteLine（$“Elpased ticks:{sw.ElapsedTicks}”）；
}

通过先创建一个大数组，然后使用

array.Copy

，我们可以实现非常合理的连接速度，即使使用非常多的数组：

public static T[] ConcatArrays<T>(params T[][] p)
{
    var position = 0;
    var outputArray = new T[p.Sum(a => a.Length)];
    foreach (var curr in p)
    {
        Array.Copy(curr, 0, outputArray, position, curr.Length);
        position += curr.Length;
    }
    return outputArray;
}

或

---

你必须使用数组吗？使用列表和AddRange（）。如果您最终需要一个数组，那么最后只需调用ToArray（）。

谢谢！优雅的解决方案。我最终选择了这种方法。谢谢。好消息！当然，要考虑多次出现和较大的数组。在我的用例中，浪费的时间可以忽略不计，但请记住。有趣的是，谢谢，BurnsBA所关心的和Yeldar Kurmangaliyev的解决方案都是最好的。我会在某个阶段试一试。谢谢，这实际上是一种可能性。更多的代码重构，但可能是值得的。

public static T[] ConcatArrays<T>(params T[][] p)
{
    var position = 0;
    var outputArray = new T[p.Sum(a => a.Length)];
    foreach (var curr in p)
    {
        Array.Copy(curr, 0, outputArray, position, curr.Length);
        position += curr.Length;
    }
    return outputArray;
}

string bigArray = ConcatArrays(arrayOne, arrayTwo, arrayThree)

string[][] arrays = new[]{arrayOne, arrayTwo, arrayThree};
string bigArray = ConcatArrays(arrays);