Question

I have developed an application that is meant to send data from client to server and back etc. using serialized objects.

For this application, I decided that protobuf-net would be a good option (especially as it handles variable-length objects so well).

However, when sending an object from client to server or vica-versa, all I know is that the object will be some child class of ‘ReplicableObject’. Hence, I am using:

Serializer.SerializeWithLengthPrefix(stream, ro, PrefixStyle.Base128);

Where ‘ro’ is an object of a type that subclasses from ReplicableObject.

However, I get this exception:

An unhandled exception of type ‘ProtoBuf.ProtoException’ occurred in
protobuf-net.dll

Additional information: Unexpected type found during serialization;
types must be included with ProtoIncludeAttribute; found MessageObject
passed as ReplicableObject

In this particular instance, I’m trying to send a MessageObject.

As there is precious little documentation for protobuf-net, I am stuck on what to do. I’ve tried a few attributes here and there to no avail.

Any help appreciated.

Edit: I should make it clear that the subclasses might not even be ones that I’ve written.

Answer 1

Protobuf is a contract-based serialization format, designed to be platform independent. As such, no type metadata is included on the wire as it would not apply between platforms. Even inheritance is not part of the core protobuf spec.

protobuf-net as a specific implementation introduces support for inheritance (via some smoke and mirrors), but ideally it should still be possible to define the expected types in advance – exactly the same as other serializers such as XmlSerializer or DataContractSerializer. This can be done by using [ProtoInclude(...)] to specify the anticipated concrete types.

If you genuinely can’t tell the actual types in advance, there is also a DynamicType option, which writes the AssemblyQualifiedName into the stream. If you are interested in this route, then note that the “cross-platform” features of the format start to break down, but it is very useful for .NET-to-.NET purposes.

At the simplest, a wrapper such as:

[ProtoContract]
public class SomeWrapper {
     [ProtoMember(1, DynamicType = true)]
     public object Value {get;set;}
}

Wrap your object in that and it should behave (in v2 at least; DynamicType did not exist in v1). Full example:

[TestFixture]
public class SO7218127
{
    [Test]
    public void Test()
    {
        var orig = new SomeWrapper {Value = new SubType { Foo = 123, Bar = "abc"}};
        var clone = Serializer.DeepClone(orig);
        Assert.AreEqual(123, orig.Value.Foo);
        Assert.AreEqual("abc", ((SubType) clone.Value).Bar);
    }
    [ProtoContract]
    public class SomeWrapper
    {
        [ProtoMember(1, DynamicType = true)]
        public BaseType Value { get; set; }
    }
    [ProtoContract]
    public class BaseType
    {
        [ProtoMember(1)]
        public int Foo { get; set; }
    }
    [ProtoContract]
    public class SubType : BaseType
    {
        [ProtoMember(2)]
        public string Bar { get; set; }
    }
}