Creating a byte array from a stream

Question

What is the preffered method for creating a byte array from an input stream?

Here is my current solution with .NET 3.5.

Is it still a better idea to read and write chunks of the stream?

Stream s;
byte[] b;
using (BinaryReader br = new BinaryReader(s)) {
 b = br.ReadBytes(s.Length);
}

Answer 1

It really depends on whether or not you can trust s.Length. For many streams, you just don't know how much data there will be. In such cases, I'd use code like this:

public static byte[] ReadFully(Stream input)
{
    byte[] buffer = new byte[16*1024];
    using (MemoryStream ms = new MemoryStream())
    {
        int read;
        while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
        {
            ms.Write(buffer, 0, read);
        }
        return ms.ToArray();
    }
}

EDIT: I should perhaps explain why my answer is longer than the others. Stream.Read doesn't guarantee that it will read everything it's asked for. If you're reading from a network stream, for example, it may read one packet's worth and then return, even if there will be more data soon. BinaryReader.Read will keep going until the end of the stream or your specified size, but you still have to know the size to start with.

The above method will keep reading (and copying into a MemoryStream) until it runs out of data. It then asks the MemoryStream to return a copy of the data in an array. If you know the size to start with - or think you know the size, without being sure - you can construct the MemoryStream to be that size to start with. Likewise you can put a check at the end, and if the length of the stream is the same size as the buffer (returned by MemoryStream.GetBuffer) then you can just return the buffer. So the above code isn't quite optimised, but will at least be correct. It doesn't assume any responsibility for closing the stream - the caller should do that.

See this article for more info (and an alternative implementation).

Answer 2

I personally use

    public byte[] GetArray(Stream s, int maxSize)
    {
        byte[] array = new byte[maxSize];
        s.Read(array, 0, (int)array.Length);
        s.Close();
        return array;
    }

You obviously need to know what is the maximum size you expect.

Be cautious: maxSize apparently needs to be lesser than 10k (see comments)

Answer 3

There is a slightly more efficient way of doing this on this site.

Answer 4

Just want to point out that in case you have a MemoryStream you already have memorystream.ToArray() for that.

Also, if you are dealing with streams of unknown or different subtypes and you can receive a MemoryStream, you can relay on said method for those cases and still use the accepted answer for the others, like this:

    public static byte[] StreamToByteArray(Stream stream)
    {
        if (stream is MemoryStream)
        {
            return ((MemoryStream)stream).ToArray();                
        }
        else
        {
            // Jon Skeet's accepted answer 
            return ReadFully(stream);
        }
    }