Returning a byte array from a method [closed]

I could be wrong, but I haven't seen other designs of serialization than :

1. Serializer with reflection (customizable through attributes/converter/mapper).

   This design is more complicated, in a sense that you have to plan ahead every the possible details of serialization. It is also harder to wire everything up, while leaving room for customization.

   it would simply consist of a large if-else/switch branch

   This really shouldn't happen unless you plan to do this : switch(element.GetType().Name). You should use reflection to pull every member or property(pick one), and use Attribute to filter amd format them. The only switch you might need to have is opposibly for the premitive types : string, int, enum, etc.

   it would force me to expose private members as internal/protected/public

   You don't have to, as you can obtain information on any member of a class, be protected or private.

2. Serializable by exposing a serialize method

   This design is more straight-forward where each element serializes its own stuffs and delegates the rest to the respective element.

I'm going to assume the document is composed of hierarchical elements. If that is case, copying and merging the bytes array could get very costly, more as we get closer to the root element. Since you mentionned that you're working with a "very specific binary representation" and writing to a "stream", it would be best to write directly on the stream, rather than copying and merging the bytes, and holding them around.

public abstract class Element
{
    // Removed for verbosity ...

    protected abstract void Serialize(BinaryWriter writer);
}

public class ElementX : Element
{
    public string Result { get; set; }
    public Element Data { get; set; }

    protected override void Serialize(BinaryWriter writer)
    {
        const string NewLine = "\r\n";
        const string Opening = "begin-elem-x";
        const string Closing = "end-elem-x";

        writer.Write(Opening);
        writer.Write(NewLine);
        writer.Write(Data);
        writer.Write(NewLine);
        writer.Write(Closing);
        writer.Write(Result);
    }
}

internal static class SerializationExtensions
{
    public static void Write(this BinaryWriter writer, Element element)
    {
        element.Serialize(writer);
    }
}

I would define IElementWriter and IElementReader using your content terminology. Let’s say for writer:

interface IElementWriter : IDisposable
{
    void Begin<TElement>();
    void End<TElement>();
    void NewLine();

    // Probably you can have a fine grained API 
    // here for better logging - something specific for your 
    // document content and potentially reusable between elements.
    // It will insure consistency on serialization formats.
    // I use CommandDiscriminator, Angle, Speed, DepthIncrement,
    // Version, Time, ... in my binary protocol - just to get an idea.
    void Data(string value); 
    void Result(string value);
}

We implement it once for stream writing:

class StreamElementWriter : IElementWriter
{
    public StreamElementWriter(Stream stream)
        : this(new StreamWriter(stream))
    {
    }
}

Another one for tracing purposes – here fine grained API is very useful.

class LogElementWriter : IElementWriter
{
    public LogElementWriter(TextWriter writer)
    {
    }
}

Composite pattern:

class CompositeElementReader : IElementWriter
{
    public CompositeElementReader(params IElementWriter[] writers)
    {
        Writers = writers;
    }

    void Begin<TElement>()
    {
        foreach (var writer in Writers)
            writer.Begin<TElement>();
    }

    IElementWriter[] Writers { get; }
}

Now you could have:

IElementReader reader = ..
var element = Element.Load(reader);

and:

IElementWriter writer = ...
element.WriteTo(writer);

ToArray method might be useful if you do need BLOB:

class Element
{
    public byte[] ToArray()
    {
        using (var stream = new MemoryStream())
        using (var writer = new StreamElementWriter(stream))
        {
            WriteTo(stream);
            return stream.ToArray();
        }
    }
}