有人可以帮我简单的算法吗？

Question

我想解析http请求下载的所有字节如果它们> 100kb，如果不是，将它们连接到缓冲区，并且当缓冲区达到>时100kb 再次解析它们并将 uffer 清空。但不是解析所有文件数据并在最终块中获取 ex: 2kb。它必须检查下一个块，以及是否最终将其连接起来（例如：final_chunk.Length + 2kb），

重点是我每次都需要解析至少 100kb 块，不少于。

Answer 1

正如 PoweRoy 所说，你已经有了算法，你只需要编码它......让我一步一步地讲。

1. 声明本地缓冲区对象
2. 发出异步/同步 HTTP 请求（我更喜欢异步调用）
3. 将其保存到缓冲区
4. 检查缓冲区大小（如果大于 100kb）
5. 如果缓冲区大小不大于 100kb 将数据附加到缓冲区
6. （如果大于 100kb） 读取缓冲并清除它。
7. 转到步骤 2

Answer 2

我想这样就可以了。我只需要用字节数组重写它。你发现任何错误吗？

        class SmartChunk {

        private int ChunkSize;
        private int DataSize;
        private int pos;
        private int len;
        private string buff = "";

        public SmartChunk(int InitChunkSize, int DataLen) {
            pos = 0;
            len = DataLen;
            ChunkSize = InitChunkSize;
        }

        public string Append(string s) {
            if (pos + ChunkSize * 2 > len) ChunkSize = len - pos;

            if (s.Length >= ChunkSize) {
                return s;
            }
            else {
                buff += s;
                if (buff.Length >= ChunkSize) {
                    pos += buff.Length;
                    string b = buff;
                    buff = "";
                    return b;
                }
            }

            return null;
        }
    }

Answer 3

这是字节数组列表：

class SmartChunk {
        private int ChunkSize;
        private int DataSize;
        private int pos;
        private int len;
        private List<byte[]> buff;

        public SmartChunk(int InitChunkSize, int DataLen) {
            buff = new List<byte[]>();
            pos = 0;
            len = DataLen;
            ChunkSize = InitChunkSize;
        }

        public List<byte[]> Append(byte[] b) {
            if (pos + ChunkSize * 2 > len) ChunkSize = len - pos;

            if (b.Length >= ChunkSize) {
                List<byte[]> priv = new List<byte[]>();
                priv.Add(b);
                return priv;
            }
            else {
                buff.Add(b);
                int total_size = 0;
                foreach(byte[] inner in buff){
                    total_size += inner.Length; 
                }

                if (total_size >= ChunkSize) {
                    pos += total_size;

                    List<byte[]> temp = new List<byte[]>(buff);
                    //foreach (byte[] tmp in buff) temp.Add(tmp);
                    buff.Clear();
                    return temp;
                }
            }

            return null;
        }
    }