在C＃中将byte []拆分为多个byte []数组

Question

我试图“填充”图像的字节。 这将允许我分批上传大图像。 我将当前存储的图像存储为一个大字节[]。 我想将字节数组拆分为byte[] ，最大长度为512个元素。 但是，我不确定如何以最有效的方式做到这一点。

有谁知道我怎么能以最有效的方式做到这一点？

Answer 1

我为此编写了一个扩展，最初用于字符串，但决定使其成为通用的。

    public static T[] CopySlice<T>(this T[] source, int index, int length, bool padToLength = false)
    {
        int n = length;
        T[] slice = null;

        if (source.Length < index + length)
        {
            n = source.Length - index;
            if (padToLength)
            {
                slice = new T[length];
            }
        }

        if(slice == null) slice = new T[n];
        Array.Copy(source, index, slice, 0, n);
        return slice;
    }

    public static IEnumerable<T[]> Slices<T>(this T[] source, int count, bool padToLength = false)
    {
        for (var i = 0; i < source.Length; i += count)
            yield return source.CopySlice(i, count, padToLength);
    }

基本上，您可以像这样使用它：

byte[] myBytes; // original byte array

foreach(byte[] copySlice in myBytes.Slices(10))
{
    // do something with each slice
}

编辑 ：我还在这里使用Buffer.BlockCopy提供了一个关于SO的答案，但是BlockCopy只能在byte[]数组上工作，所以字符串的通用版本是不可能的。

Answer 2

最有效的方法是：不要。 如果您已经将图像作为单个字节[]，那么对于本地代码，只需指定偏移量和长度（可能是字节ArraySegment-of-byte）通常就足够了。 如果你的上传API只接受byte []，那么你仍然不应该把它完全分块; 只需使用单个512缓冲区并使用Buffer.BlockCopy加载它将连续的数据片段。 您可能需要调整最终块的大小（Array.Resize），但最多需要2个阵列。

更好; 首先避免使用byte []：考虑通过流API加载数据（如果数据来自文件，这将很有效）; 只需使用Read（在循环中，处理返回的值等）来填充max 512的块。例如（未经测试，仅用于说明）：

byte[] buffer = new byte[512];
while(true) {
    int space = 512, read, offset = 0;
    while(space > 0 && (read = stream.Read(buffer, offset, space)) > 0) {
        space -= read;
        offset += read;
    }
    // either a full buffer, or EOF
    if(space != 0) { // EOF - final
       if(offset != 0) { // something to send
         Array.Resize(red buffer, offset);
         Upload(buffer);
       }
       break;
    } else { // full buffer
       Upload(buffer);
    }
}

Answer 3

public static IEnumerable<byte[]> Split(this byte[] value,int bufferLength){
   int countOfArray = value.Length / bufferLength;
   if(value.Length % bufferLength > 0)
      countOfArray ++;
   for(int i=0;i<countOfArray;i++)
   {
      yield return value.Skip(i * bufferLength).Take(bufferLength).ToArray();

   }
}

这是我使用的扩展

Answer 4

我知道这是旧的，但需要相同的解决方案和以下工作完美的我希望这有助于某人

private byte[][] ByteArrayToChunks(byte[] byteData, long BufferSize)
{
    byte[][] chunks = byteData.Select((value, index) => new { PairNum = Math.Floor(index / (double)BufferSize), value }).GroupBy(pair => pair.PairNum).Select(grp => grp.Select(g => g.value).ToArray()).ToArray();
    return chunks;
}