Question

我有一个byte []数组说任何长度，我想将它分成几部分，每个部分的长度为2205，我将不得不对这些2205字节进行操作，这是我的算法：

// SPLIT BY 2205 Bytes
int block = 2205;
int counter = 0;
byte[] to_Send = new byte[block];
foreach (byte b in ARCHIEVE_BUFFER)
{
    if (counter < 2205)
    {
        to_Send[counter] = b;
        counter++;
    }
    else if (counter == 2205)
    {
        // do some operation on those 2205 bytes which stored on the array to_send

        counter = 0;
        to_Send[counter] = b;
        counter++;
    }
}

我只想将数组拆分为固定数量的范围

Answer 1

使用linq，您可以将数组拆分为blocksize字节块

int count=0;
int blocksize = 2205;
List<List<byte>> blocks =  ARCHIEVE_BUFFER
                            .GroupBy( _ => count++ / blocksize)
                            .Select(x=>x.ToList())
                            .ToList();

Answer 2

类Array有一个静态方法，它从一个数组复制到另一个数组，从两个数组中的一个位置开始并指定长度

Array.Copy(array1, pos1, array2, pos2, length)

int block = 2205;
int counter = 0;
byte[] to_Send = new byte[block];
Array.Copy(ARCHIEVE_BUFFER, 0, to_Send, 0, 2205);

一旦用第一个块填充，你不清楚你想用to_Send数组做什么，但是应该很容易在Array.Copy周围添加一个循环来改变每个循环的起始位置并使用从ARCHIEVE_BUFFER中提取的新数据

Answer 3

创建一个新数组并使用Buffer.BlockCopy。迭代一个数组并复制Byte per Byte是安静的。

byte[] toSend = null;
int Remaining = ARCHIEVE_BUFFER.Length;
int Packed = 0;

while(Remaining > 0){
   toSend = new byte[Remaining >= block ? block : Remaining];
   Buffer.BlockCopy(toSend, 0, ARCHIEVE_BUFFER, Packed, toSend.Length); // not sure about params
   Packed += toSend.Length;
   Remaining -= toSend.Length;

   // todo: send here
}

Answer 4

如上所述，使用Array.Copy方法或Buffer.BlockCopy。但是，在性能危急情况下，请使用BlockCopy。

Array.Copy(sourceArray, 0, destinationArray, 0, size);

或

Buffer.BlockCopy(sourceArray, 0, destinationArray, 0, size);

Answer 5

或者通过另一种方式，使用Enumerable.Skip和Enumerable.Take：

//ARCHIEVE_BUFFER: source array 
//block: the size of slice
for(var i=0; i<ARCHIEVE_BUFFER.Length;i+=block) {
    var to_Send = ARCHIEVE_BUFFER.Skip(i).Take(block);
    ProcessSubArray(to_Send);
}

C＃将数组拆分为固定数量的范围

5 个答案: