Question

We have the following..

public class Foo
{
   public string Name { get; private set;}

   private Foo(string name)
   {
      Name = name;
   }

   public Foo Instance1 = new Foo("Hello");
   public Foo Instance2 = new Foo("World");
}

And then referencing this we would have..

[ProtoContract]
public class Bar 
{
   [ProtoMember(1)]
   public Foo Foo { get; private set; }

   public Bar(Foo foo)
   {
      Foo = foo;
   }
}

So when I deserialize a Bar I need it to get a reference to either Foo.Instance1 or Foo.Instance2..

The question is can I do this and if so how?

Answer 1

There are several ways this could be approached. The simplest would be to add a shim property, i.e.

public Foo Foo { get; private set; }

[ProtoMember(1)]
private SomeBasicEnum FooSerialization {
   /* shim between Foo and SomeBasicEnum in get/set */
}

However, if you have lots of Foo properties this could be a pain. So instead, v2 offers “surrogate” types – i.e. as long as it can locate a conversion operator between 2 types, it will happily swap them for you automatically. In this case we’d want to swap to an enum, and since you can’t add operators to enums you’d have to add the operator to Foo:

public static implicit operator Foo(FooSurrogate value)
{
    switch (value)
    {
        case FooSurrogate.Nil: return null;
        case FooSurrogate.Instance1: return Foo.Instance1;
        case FooSurrogate.Instance2: return Foo.Instance2;
        default: throw new InvalidEnumArgumentException("value");
    }
}
public static implicit operator FooSurrogate(Foo value)
{
    if (value == null) return FooSurrogate.Nil;
    if (value == Foo.Instance1) return FooSurrogate.Instance1;
    if (value == Foo.Instance2) return FooSurrogate.Instance2;
    throw new InvalidEnumArgumentException("value");
}

and have a simple enum somewhere:

public enum FooSurrogate
{
    Nil, Instance1, Instance2
}

And configure it (somewhere at app-startup):

RuntimeTypeModel.Default.Add(typeof(Foo), false).SetSurrogate(
                   typeof(FooSurrogate));

And we’re good to go. A minor tweak is also required because Bar lacks a parameterless constructor; 2 options here:

1. add a private Bar() {} that it can use
2. explicitly tell it not to use a constructor: [ProtoContract(SkipConstructor = true)]

Add a test rig:

static void Main()
{
    RuntimeTypeModel.Default.Add(typeof(Foo), false).SetSurrogate(
              typeof(FooSurrogate));
    var obj = new Bar(Foo.Instance1);
    var clone = Serializer.DeepClone(obj);

    bool same = ReferenceEquals(obj.Foo, clone.Foo);
    Debug.Assert(same); // passes
}

I could probably also make it possible to use external operator-esque methods to avoid having to have the operator on Foo, which is a bit ugly.

A final option would be for me to add IObjectReference support, but frankly (and especially in this case), using a basic enum for the implementation is tidier and more efficient.