Question

我正在尝试将字节流拆分为越来越大的块。

源流包含未知数量的字节，读取起来很昂贵。枚举器的输出应该是大小增加的字节数组，从8KB开始到1MB。

这很简单，只需读取整个流，将其存储在一个数组中并取出相关的部分即可。但是，由于流可能非常大，因此立即读取它是不可行的。此外，虽然性能不是主要问题，但保持系统负载非常低非常重要。

在实现这一点时，我注意到保持代码简短和可维护起来相对困难。还要记住一些与流相关的问题（例如，即使成功，Stream.Read也可能无法填充缓冲区。）

我没有找到任何可以帮助我的案例的现有课程，也无法在网上发现任何内容。你会如何实现这样的课程？

Answer 1

public IEnumerable<BufferWrapper> getBytes(Stream stream)
{
    List<int> bufferSizes = new List<int>() { 8192, 65536, 220160, 1048576 };
    int count = 0;
    int bufferSizePostion = 0;
    byte[] buffer = new byte[bufferSizes[0]];
    bool done = false;
    while (!done)
    {
        BufferWrapper nextResult = new BufferWrapper();
        nextResult.bytesRead = stream.Read(buffer, 0, buffer.Length);
        nextResult.buffer = buffer;
        done = nextResult.bytesRead == 0;
        if (!done)
        {
            yield return nextResult;
            count++;
            if (count > 10 && bufferSizePostion < bufferSizes.Count)
            {
                count = 0;
                bufferSizePostion++;
                buffer = new byte[bufferSizes[bufferSizePostion]];
            }
        }
    }
}

public class BufferWrapper
{
    public byte[] buffer { get; set; }
    public int bytesRead { get; set; }
}

显然，何时向上移动缓冲区大小的逻辑，以及如何选择那个大小的逻辑可以改变。

有人也可能找到一种更好的方法来处理要发送的最后一个缓冲区，因为这不是最有效的方法。

Answer 2

供参考，我目前正在使用的实现，已根据@Servy

的答案进行了改进

private const int InitialBlockSize = 8 * 1024;
private const int MaximumBlockSize = 1024 * 1024;

private Stream _Stream;
private int _Size = InitialBlockSize;

public byte[] Current
{
    get;
    private set;
}

public bool MoveNext ()
{
    if (_Size < 0) {
        return false;
    }

    var buf = new byte[_Size];
    int count = 0;

    while (count < _Size) {
        int read = _Stream.Read (buf, count, _Size - count);

        if (read == 0) {
            break;
        }

        count += read;
    }

    if (count == _Size) {
        Current = buf;
        if (_Size <= MaximumBlockSize / 2) {
            _Size *= 2;
        }
    }
    else {
        Current = new byte[count];
        Array.Copy (buf, Current, count);
        _Size = -1;
    }

    return true;
}

如何实现一个lazy stream chunk枚举器？

2 个答案: