Serializing object property with custom converter

[AlleSchonWeg]

Hi,
i have a class with a property of object. Like this:

[GenerateShape]
public partial class TestModels
{
		[MessagePackConverter(typeof(MyConverter))]
        public object Tag { get; set; } = null!;
}

To serialize the property i created a MessagePackConverter like mentioned in the migration section: https://aarnott.github.io/Nerdbank.MessagePack/docs/migrating.html#incompatibilities
Here is my converter:

    public class MyConverter : MessagePackConverter<object>
    {
        public override object? Read(ref MessagePackReader reader, SerializationContext context)
        {
            if (reader.TryReadNil())
            {
                return null;
            }
            //var test = context["test"]; //Dict ist hier leer
            var count = reader.ReadArrayHeader(); //Read the array header
            // var myClass = context.GetConverter<MyClass>(context.TypeShapeProvider).Read(ref reader, context);
            var type = reader.ReadString(); //Read the type name, e.g. "MyClass"

            switch (type)
            {
                case nameof(MyClass):
                    {
                        var my = context.GetConverter<MyClass>(context.TypeShapeProvider).Read(ref reader, context);
                        return my;
                        break;
                    }
                case nameof(MyClass2):
                    {
                        var my = context.GetConverter<MyClass2>(context.TypeShapeProvider).Read(ref reader, context);
                        return my;
                        break;
                    }
                default:
                    throw new NotSupportedException($"Type '{type}' is not supported.");
            }
        }

        public override void Write(ref MessagePackWriter writer, in object? value, SerializationContext context)
        {
            if (value is null)
            {
                writer.WriteNil();
                return;
            }
            writer.WriteArrayHeader(2);
            switch (value.GetType().Name)
            {
                case nameof(MyClass):
                    {
                        writer.Write(nameof(MyClass));
                        context.GetConverter<MyClass>(context.TypeShapeProvider).Write(ref writer, (MyClass)value, context);
                        break;
                    }
                case nameof(MyClass2):
                    {
                        writer.Write(nameof(MyClass2));
                        context.GetConverter<MyClass2>(context.TypeShapeProvider).Write(ref writer, (MyClass2)value, context);
                        break;
                    }
                default:
                    throw new NotSupportedException($"Type '{value.GetType().Name}' is not supported.");
            }
        }
    }

For testing i create two classes which can set as Tag in my model:

    [GenerateShape]
    public partial class MyClass
    {
        public DateTime t = DateTime.Now;
        public DateTimeOffset qt = DateTimeOffset.Now;
    }

    [GenerateShape]
    public class MyClass2
    {
        public DateTime t = DateTime.Now;
        public DateTimeOffset qt = DateTimeOffset.Now;
        public string Name2 { get; set; } = "Hallo";
        public int Age { get; set; } = 55;
        public void AddToDict()
        {
            Dict.Add(4, "vier");
            Dict.Add(5, "fgdfg");
            Dict.Add(6, "dfg");
            Dict.Add(7, "fgfdg");
        }
        public Dictionary<int, string> Dict { get; set; } = new Dictionary<int, string>();
    }

This works great. I can successfully serialize and deserialize objects from type TestModels with the Tag property of type MyClass or MyClass2.
But i want to know if this is the recommended procedure to handle object type properties? I'm not sure if there is a better approach, especially in performance and if i have not only 2 possible types for the Tag property.
The serialization/deserialisation is for transferring data via grpc between intranet applications.

Thank you

[AArnott]

Aside from minor syntax issues that could be improved, what you've done here is quite reasonable. It's actually quite similar to how unions work, but unions require a common base type or interface across all the runtime types.

[AlleSchonWeg]

Hi @AArnott ,

thank you very much for your answer. I rewrote the converter added the namespace (type.FullName) and only call writer.WriteArrayHeader when the type is supported for the object Tag:

    public class MyConverter : MessagePackConverter<object>
    {
        public override object? Read(ref MessagePackReader reader, SerializationContext context)
        {
            if (reader.TryReadNil())
            {
                return null;
            }
            //var test = context["test"]; //Dict ist hier leer
            var count = reader.ReadArrayHeader(); //Read the array header
            var type = reader.ReadString(); //Read the type name, e.g. "MyClass"
            if (string.IsNullOrWhiteSpace(type))
                return null;
            switch (type)
            {
                case $"{nameof(Contract)}.{nameof(MyClass)}":
                    return context.GetConverter<MyClass>(context.TypeShapeProvider).Read(ref reader, context);
                case $"{nameof(Contract)}.{nameof(MyClass2)}":
                    return context.GetConverter<MyClass2>(context.TypeShapeProvider).Read(ref reader, context);
                default:
                    throw new NotSupportedException($"Type '{type}' is not supported.");
            }
        }

        public override void Write(ref MessagePackWriter writer, in object? value, SerializationContext context)
        {
            if (value is null)
            {
                writer.WriteNil();
                return;
            }
            var type = value.GetType();
            switch (value)
            {
                case MyClass:
                case MyClass2:
                    Write(ref writer, value, context, type);
                    break;
                default:
                    throw new NotSupportedException($"Type '{type.FullName}' is not supported.");
            }
        }

        private static void Write(ref MessagePackWriter writer, in object? value, SerializationContext context, Type type)
        {
            writer.WriteArrayHeader(2);
            writer.Write(type.FullName);
            context.GetConverter(type, context.TypeShapeProvider).WriteObject(ref writer, value, context);
            //context.GetConverter<T>(context.TypeShapeProvider).Write(ref writer, (T)value, context);
        }
    }

I also tried it with a common base class:

[GenerateShape]
public partial class TestModels
{
		[MessagePackConverter(typeof(MyConverter))]
        public object Tag { get; set; } = null!;
		
		public Bucket TestBucket { set; get; } //Test with base class
}
[GenerateShape]
[DerivedTypeShape(typeof(Bucket<MyClass>), Name = nameof(MyClass))]
[DerivedTypeShape(typeof(Bucket<MyClass2>), Name = nameof(MyClass2))]
public abstract partial class Bucket
{
    public static Bucket Create<T>(T value)
    {
        return new Bucket<T> { Value = value };
    }
}
[GenerateShape]
public partial class Bucket<T> : Bucket
{
    public T Value { get; set; } = default!;
}

I could refactor my real world app and remove the object Tag property and replace it with the base class approach. I know which types i need. Most important is performance in my case. Not versioning or other things.
With your experience what should i prefer? The converter or the unions?

I also need to (de)serialize private/internal properties and fields. It is possible to enable this globaly? Because without this i have a lot work in my app.

Thanks again

[AArnott]

With your experience what should i prefer? The converter or the unions?

I suggest conforming to what unions supports, because fewer custom converters is usually better. And the built-in ones are far more fully featured and optimized than yours or what I'd expect most other hand-authored converters to support.

If you keep your converter though, here's a suggestion: Your Read method shouldn't discard the result from ReadArrayHeader. You should verify that it is exactly 2 before reading more tokens so that you catch bugs or data corruption sooner.

I also need to (de)serialize private/internal properties and fields. It is possible to enable this globaly? Because without this i have a lot work in my app.

We support private field serialization but the fields must be attributed with [PropertyShape] attributes. There's no way to flip a switch to include them automatically, and honestly you probably wouldn't like the result if you could. Think about all properties: they have fields backing them. Even if we could magically tell which fields backed auto-properties, the manually declared properties with backing fields would get serialized twice by default. Not a good story.

[AlleSchonWeg]

Hi @AArnott
is the project stable enough to use it in a project with customers?
Atm I can't include the serializer because it's a RC. This is against our company policies.
Thank you

[AArnott]

It's functionally stable, yes. But I can't release it as a stable package quite yet because it has an unstable dependency (PolyType). I'm working with the PolyType author to get a stable release out sometime in the next several weeks, at which point Nerdbank.MessagePack will get a stable 1.0 release.

[AlleSchonWeg]

Just for info. I want to use MessagePack in ServiceModel.Grpc: https://github.com/max-ieremenko/ServiceModel.Grpc
This is my use case. ;)

[AArnott]

Can you help me understand the overlap between gRPC and MessagePack? Doesn't gRPC prescribe its own format?