C# 合并保留顺序的集合的最有效方法？

我有3个频道：

byte[] Red;
byte[] Green;
byte[] Blue;

我需要将所有值从它们复制到一个

字节[Red.Length+Green.Length+Blue.Length]PA

，以便：

PA[0] = Red[0];
PA[1] = Green[0];
PA[2] = Blue[0];
PA[3] = Red[1];
/// and so on

以下是上述阵列的示例：

byte[] Red = new byte[255];
byte[] Green = new byte[255];
byte[] Blue = new byte[255];
byte[] PA = new byte[Red.Length + Green.Length + Blue.Length];
for (int i = 0; i != 255; ++i)
{
    PA[i*3 + 0] = Red[i];
    PA[i*3 + 1] = Green[i];
    PA[i*3 + 2] = Blue[i];
}

我假设要合并的集合大小相等，并且它们之间确实有一些顺序，例如，必须为“合并”集合中的项目保留的红色、绿色等

---

在

C#

中，最有效的方法是什么？集合不必是数组，也不必是项字节（尽管接受字节的集合类型会受到欢迎）。

效率是一个很薄的决策层，但从性能角度来看，我认为您已经以高效的方式完成了

//allocate immediately memory need, so more shrinking of memory will happen 
byte[] PA = new byte[Red.Length + Green.Length + Blue.Length]; 

//use for loop, that normally equals to foreach in some cases is faster
for (int i = 0; i != 255; ++i)
{
    PA[i + 0] = Red[i];
    PA[i + 1] = Green[i];
    PA[i + 2] = Blue[i];
}

---

我会尽量避免

3*I

乘法：

byte[] Red = new byte[255];
byte[] Green = new byte[255];
byte[] Blue = new byte[255];
int newSize = Red.Length + Green.Length + Blue.Length;
byte[] PA = new byte[newSize];
for (int i = 0; i < newSize; i += 3)
{
    PA[i + 0] = Red[i];
    PA[i + 1] = Green[i];
    PA[i + 2] = Blue[i];
}

byte[]红色=新字节[255]；
字节[]绿色=新字节[255]；
字节[]蓝色=新字节[255]；
int newSize=Red.Length+Green.Length+Blue.Length；
字节[]PA=新字节[newSize]；
对于（int i=0；i

编辑

或者甚至类似的事情：

for (int i = 0, j = 0; i < 255; i++)
{
    PA[j++] = Red[i];
    PA[j++] = Green[i];
    PA[j++] = Blue[i];
}

for（int i=0，j=0；i<255；i++）
{
PA[j++]=红色[i]；
PA[j++]=绿色[i]；
PA[j++]=蓝色[i]；
}

---

（建议）

我试图通过使用指针来实现一种更有效的方法：

unsafe {
  fixed (byte* red = Red, green = Green, blue = Blue, pa = PA2) {
    byte* r = red, g = green, b = blue, p = pa;
    for (int i = 0; i < 255; i++) {
      *p = *r; p++; r++;
      *p = *g; p++; g++;
      *p = *b; p++; b++;
    }
  }
}

不安全{
固定（字节*红色=红色，绿色=绿色，蓝色=蓝色，pa=PA2）{
字节*r=红色，g=绿色，b=蓝色，p=pa；
对于（int i=0；i<255；i++）{
*p=*r；p++；r++；
*p=*g；p++；g++；
*p=*b；p++；b++；
}
}
}

在x86模式下，速度大约是x64模式的两倍，但在x64模式下没有区别

---

总之，您拥有的代码对于大多数应用程序来说已经足够快了。如果您需要它非常快，您可以对它进行一些优化，但不会太多。

对不起，这只是我现在使用的代码的剩余部分（出于其他原因需要这样做）。@Default:no但他可能需要两个索引器，一个用于快进目标数组，另一个用于跟踪源数组。@WiktorZychla我删除了我的注释，因为我误读了逻辑。不过这是一种有趣的方法。：）顺便说一句，刚刚做了一些测试，我的方法似乎仍然比2个整数的方法快一点。使用！=20年前，for-loop-guard被认为是一种不好的做法；）我认为从那时起情况没有改变。另外，你不能仅仅将索引增加1，因为你的G和B在下一个循环中将被R覆盖。我听说使用！=实际上更快（如果我错了，请随时纠正我）。@StefanDenchev：因为在某些测量中，迭代速度更快，然后是foreach。@StefanDenchev对于

int

等类型，从效率的角度来看，

您的代码看起来还可以。您是否发现它有什么问题（除了
i！=255
在
for
循环中）？不是真的。我只是想知道.NET是否能提供更好的服务，我想。@StefanDenchev没问题：）