Why do most serializers use a stream instead of a

Question

I am currently working on a socket server and I was wondering Why do serializers like

• XmlSerializer
• BinaryFormatter
• Protobuf-net
• DataContractSerializer

all require a Stream instead of a byte array?

Answer 1

It means you can stream to arbitrary destinations rather than just to memory.

If you want to write something to a file, why would you want to create a complete copy in memory first? In some cases that could cause you to use a lot of extra memory, possibly causing a failure.

If you want to create a byte array, just use a MemoryStream:

var memoryStream = new MemoryStream();
serializer.Write(foo, memoryStream); // Or whatever you're using
var bytes = memoryStream.ToArray();

So with an abstraction of "you use streams" you can easily work with memory - but if the abstraction is "you use a byte array" you are forced to work with memory even if you don't want to.

Answer 2

@JonSkeet's answer is the correct one, but as an addendum, if the issue you're having with making a temporary stream is "I don't like it because it's effort" then consider writing an extension method:

namespace Project.Extensions
{
    public static class XmlSerialiserExtensions
    {
        public static void Serialise(this XmlSerializer serialiser, byte[] bytes, object obj)
        {
            using(var temp = new MemoryStream(bytes))
                serialiser.Serialize(temp, obj);
        }

        public static object Deserialise(this XmlSerializer serialiser, byte[] bytes)
        {
            using(var temp = new MemoryStream(bytes))
                return serialiser.Deserialize(temp);
        }
    }
}

So you can go ahead and do

serialiser.Serialise(buffer, obj);
socket.Write(buffer);

Or

socket.Read(buffer);
var obj = serialiser.Deserialise(buffer);

Answer 3

You can easily make a stream over a byte array...but a byte array is inherently size-constrained, where a stream is open-ended...big as you need. Some serialization can be pretty enormous.

Edit: Also, if I need to implement some kind of serialization, I want to do it for the most basic abstraction, and avoid having to do it over multiple abstractions. Stream would be my choice, as there are stream implementations over lots of things: memory, disk, network and so forth. As an implementer, I get those for "free".

Answer 4

Byte arrays were used more often when manipulating ASCII (i.e. 1-byte) strings of characters often in machine dependent applications, such as buffers. They lend themselves more to low-level applications, whereas "streams" is a more generalized way of dealing with data, which enables a wider range of applications. Also, streams are a more abstract way of looking at data, which allows considerations such as character type (UTF-8, UTF-16, ASCII, etc.) to be handled by code that is invisible to the user of the data stream.

Answer 5

if you use a byte array/ buffer you are working temporarily in memory and you are limited in size

While a stream is something that lets you store things on disk, send across to other computers such as the internet, serial port, etc. streams often use buffers to optimize transmission speed.

So streaming will be useful if you are dealing with a large file