Question

我想解析http请求下载的所有字节，如果它们是＆gt; 100kb，如果不是，则将它们连接到缓冲区并且当缓冲区得到＆gt; 100kb再次解析它们并使uffer无效。但是不要解析所有文件数据和最终的块来获得ex：2kb。它必须检查下一个块，如果它是最终连接它（例如：final_chunk.Length + 2kb）

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

Answer 1

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

声明本地缓冲区对象
制作异步/同步HTTP请求（我更喜欢异步调用）
将其保存到缓冲区
检查缓冲区大小（如果大于100kb）
如果缓冲区大小不是> 100kb将数据附加到缓冲区
如果＆gt; 100kb读取缓冲区并清除它。
转到第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;
        }
    }

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

3 个答案: