[C#] Support for immutable type definitions

[Horusiath]

Right now Bond constraints serialized types to expose default constructor and properties with public getters/setters. One of the possible use cases for bond would be a message-driven systems, where message immutability is highly desired.

It would be great if Bond wouldn't require types to have public default constructors and support readonly fields and properties. A lot of high-perf serializers supports those features i.e. protobuf or Hyperion.

[chwarr]

The gbc C# mode flag --readonly-properties can be used to generate classes with private setters. This still generates a default, parameter-less constructor. It doesn't generate a constructor that takes field values as arguments: unfortunately, you'll still have to write the constructor by hand.

If someone were interested in contributing to codegen to have it generate full constructors, that would be a nice thing to have. I think the design here is that the constructors are behind a flag like --constructors and that flag is incompatible with bond_meta field types.

In our spare time, @ant0nsc and I are working on F# support. Things like annotated records and gbc-based codegen. This has resulted in our doing much of the ground work for immutable, construct-only types. Since this is a spare-time thing for both of us, I can't give you a time line for when it will ship.

There a distinct possibility that the classes generated by --readonly-properties cannot be serialized/deserialized in environments where we cannot access private member via reflection (e.g., some phone environments).

[grant-d]

"write the constructor by hand" - I assume that means we do that in a related partial class.
I remember trying to do that and (unless I did something wrong) it would not compile - it seemed the codegen did not happen in time for VS to accept assignment to IDL fields. If this is expected to work, is there a unit/sample somewhere?

[chwarr]

I don't have a specific example to point you at, but I just got the following to work:

foo.bond

namespace ReadonlyProps;

struct Foo
{
    0: int32 Bar = 45;
    1: string Baz = "hello";
}

foo.cs

namespace ReadonlyProps
{
    using System;
    using System.Diagnostics;

    using Bond;
    using Bond.IO.Safe;
    using Bond.Protocols;

    public partial class Foo
    {
        public Foo(int bar, string baz) : this("", "")
        {
            Bar = bar;
            Baz = baz;
        }
    }

    internal static class Program
    {
        private static void Main()
        {
            var f = new Foo(100, "one hundred");

            var d = SerializeCB(f);

            var f2 = DeserializeCB<Foo>(d);

            Debug.Assert(f.Bar == f2.Bar);
            Debug.Assert(f.Baz == f2.Baz);
        }

        private static ArraySegment<byte> SerializeCB<T>(T obj)
        {
            var output = new OutputBuffer();
            var cbWriter = new CompactBinaryWriter<OutputBuffer>(output);

            var serializer = new Serializer<CompactBinaryWriter<OutputBuffer>>(typeof (T));
            serializer.Serialize(obj, cbWriter);

            return output.Data;
        }

        private static T DeserializeCB<T>(ArraySegment<byte> payload)
        {
            var input = new InputBuffer(payload);
            var cbReader = new CompactBinaryReader<InputBuffer>(input);

            var deserializer = new Deserializer<CompactBinaryReader<InputBuffer>>(typeof (T));
            return deserializer.Deserialize<T>(cbReader);
        }
    }
}

foo.csproj

...
  <ItemGroup>
    <BondCodeGen Include="foo.bond">
      <Options>--readonly-properties</Options>
    </BondCodeGen>
  </ItemGroup>
...

[grant-d]

Thanks Chris, that should work fine - appreciate the sample

[bsagal]

In order to fully implement immutable types an option is needed to to allow read only collection properties.

There is already an option to use interfaces rather than concrete collection types, maybe an option can be added to use read only collection interfaces or immutable collection.