C# 比较并完成两个数组

我需要将阵列与阵列模型进行比较，并完成结构，如以下示例所示：

array = [0,1,2,3,4]
model = [0,0,0,0,0,0,0]

result = [0,1,2,3,4,0,0]

模型无法更改，它是一个引用数组

---

关于实现这一目标的最佳方法，您有什么想法吗？

您可以这样做：

var array = new[]{0,1,2,3,4};
var model = new[]{0,0,0,0,0,0,0};

var result = array.Concat(model.Skip(array.Length)).ToArray();

这将从

数组

末尾的

模型

中查找缺少的元素

---

---

和是在命名空间

System.LINQ

中的

Enumerable

类中声明的LINQ扩展方法。因此，您需要使用System.Linq添加

到您的代码中。
将短代码复制到长代码中：

int[] array = { 0, 1, 2, 3, 4 };
int[] model = { 0, 0, 0, 0, 0, 0, 0, };


int[] result = model;

array.CopyTo(result, 0);

Console.WriteLine(String.Join(" ", result));

如果您在评论中写道“最佳”意味着“最快”，那么下面是一个比较：

Stopwatch st = new Stopwatch();

int[] array = new int[10000];
int[] model = new int[10200];

st.Start();
var asdf = array.Concat(model.Skip(array.Length)).ToArray();
st.Stop();
Console.WriteLine("Concat: " + st.ElapsedMilliseconds);


int[] arraya = new int[10000];
int[]  modela = new int[10200];

st.Restart();
int[] result = modela;
arraya.CopyTo(result, 0);
st.Stop();
Console.WriteLine("Copy: " + st.ElapsedMilliseconds);

如果你预先知道数组长度，你可以这样做

int[] array = { 0, 1, 2, 3, 4 };
int[] model = { 0, 0, 0, 0, 0, 0, 0, };

Array.Copy(array, model, array.Length);

如果不是，你可以这样做

int[] model = { 0, 1, 2, 3, 4 };
var array = new int[7];

var shorter = array.Length < model.Length ? array : model;
var longer = array.Length >= model.Length ? array : model;
Array.Copy(shorter, longer, shorter.Length);

int[]model={0,1,2,3,4}；
var数组=新整数[7]；
var shorter=数组.Length<模型.Length？阵列：模型；
var longer=array.Length>=model.Length？阵列：模型；
数组.Copy（短、长、短.Length）；

。。。最快的没有原物变异

int[] array = { 0, 1, 2, 3, 4 };
int[] model = { 4,5,6,7,8,9,1, };

var x = array.Length < model.Length ?
    new { s = array, l = model, sl = array.Length, ll = model.Length } :
    new { s = model, l = array, sl = model.Length, ll = array.Length };

var result = new int[x.ll];

Array.Copy(x.s, result, x.sl);
Array.Copy(x.l, x.sl, result, x.sl, x.ll - x.sl);

int[]数组={0,1,2,3,4}；
int[]模型={4,5,6,7,8,9,1，}；
var x=数组.Length<模型.Length？
新{s=array，l=model，sl=array.Length，ll=model.Length}：
新的{s=model，l=array，sl=model.Length，ll=array.Length}；
var结果=新整数[x.ll]；
Array.Copy（x.s，result，x.sl）；
复制（x.l，x.sl，result，x.sl，x.ll-x.sl）；
这是我的版本。。。可能比林克快一点。我的假设是您正在用更大的数字替换基于数组的，但我可能错了

var array = new[]{0,1,2,3,4};
var model = new[]{0,0,0,0,0,0,0};
for(int i = 0; i < array.Length; i++)
{    
    if(array[i] > model[i])
    {
        model[i] = array[i];
    }
}

var数组=new[]{0,1,2,3,4}；
var模型=新[]{0,0,0,0,0,0}；
for（int i=0；i模型[i]）
{
模型[i]=数组[i]；
}
}

如果不是，你可以简单地做一个数组。复制
比较的依据是什么？“大，小，相等？”MongZhu因为我的理解不同于zerodefine best。最快的？可能更少的代码。。。不要忘记
Enumerable.Zip
例如
array.Zip（model，（f，s）=>f-s）@CallbackKid，它将迭代到两个序列中较短的一个，因此它不会包括示例中的尾随零。我收到消息“System.Array没有“Concat”的定义，我忘记了任何引用？@user3571412是的，它们是LINQ扩展。使用System.Linq添加
。更新了我的答案。这不会是最快的。@MatthewWhited这肯定是真的，但我看不出性能是OP的问题。甚至可能有“内存使用最少”或“代码最短”这样的矛盾标准。我只是在必要时才开始微优化。@user3571412我刚才读了你在问题下面的评论，这实际上是你正在寻找的最快的。所以这里肯定有更快的答案。请记住下次在您的问题中添加这些要求：）如果您想要最快的速度，您需要在循环之前移动
数组。长度
检查。呃，我实际上假设用户已经知道他们的数组结构。是的，但每次通过时都会调用
数组。长度
。do
var len=array.Length；对于（var i=0；iWow！我怀疑这是否会有任何性能意义，我以前遇到过…任何基准链接？对于调试中的7个元素…可能。我认为OP不希望在操作过程中更改他的
模型
。如果只是复制到更大的数组，我会这样做。然后声明一个新数组并在..
Arr中复制这两个数组除了展开循环外，复制几乎是最快的选择。