Question

I have an IInputStream that I want to read data from until I encounter a certain byte, at which point I will pass the IInputStream to some other object to consume the rest of the stream.

This is what I’ve come up with:

public async Task HandleInputStream(IInputStream instream)
{
    using (var dataReader = new DataReader(instream))
    {
        byte b;
        do
        {
            await dataReader.LoadAsync(1);
            b = dataReader.ReadByte();

            // Do something with the byte
        } while (b != <some condition>);

        dataReader.DetachStream();
    }
}

It seems like running LoadData for one byte at a time will be horribly slow. My dilemma is that if I pick a buffer size (like 1024) and load that, and my value shows up 10 bytes in, then this method will have the next 1014 bytes of data and will have to pass it to the next method for processing.

Is there a better way to approach this, or is this an acceptable solution?

Answer 1

If the value you’re looking for is not too far from the beginning of the stream, this kind of reading shouldn’t be that slow. How far into the stream are you expecting it? Have you tested the performance?

Depending on the type of stream you are using, you might be able to use other approaches:

• If it supports seeking backwards (e.g. you’re reading from a file), you could read larger chuncks at once as long as you know at what offset you have found your value. You can then seek into the stream to that position before you hand it off.
• If that’s not possible you could create another intermediate memory stream into which you would copy the remaining part of the buffer you have already read, followed by the rest of the stream. This works even if you can’t seek backwards. The only problem might be memory consumption if the stream is too large.