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

本文关键字：范围 数组 拆分 | 更新日期: 2023-09-27 18:23:44

我有一个任意长度的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++;
    }
}

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

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

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

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

类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数组一旦填充了第一个块，您想对它做什么还不清楚，但应该很容易在数组周围添加一个循环。复制更改每个循环的起始位置，并使用从ARCHIVE_BUFFER 提取的新数据

创建一个新的数组并使用Buffer.BlockCopy。在数组上迭代并按字节复制字节在性能上是安静的。

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
}

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

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

或

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

或者另一种方式，使用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);
}
相关文章：