Annotationless polymorphic union types about zeroformatter HOT 8 CLOSED

public interface IDynamicRoot
{
}

[ZeroFormattable]
public class TypeA : IDynamicRoot {}

[ZeroFormattable]
public class TypeB : IDynamicRoot{}

// RegisterDynamic? : key as byte(binary size)
Formatter.RegisterDynamicUnion<IDynamicRoot, byte>(x =>
{
    x.Register(key: (byte)0, subType: typeof(TypeA));
    x.Register(key: (byte)1, subType: typeof(TypeB));
});

// RegisterDynamic? : key as string(convenient but use many binary spaces)
Formatter.RegisterDynamicUnion<IDynamicRoot, string>(x =>
{
    // Scan rules can be freely built(manual? assembly scan +attribute? etc...).
    x.Register(key: typeof(TypeA).FullName, subType: typeof(TypeA));
    x.Register(key: nameof(TypeB).FullName, subType: typeof(TypeB));
});

// Serialize/Deserialize...
var bin = ZeroFormatterSerializer.Serialize<IDynamicRoot>(new TypeA());

// o is TypeA
var o = ZeroFormatterSerializer.Deserialize<IDynamicRoot>(bin);

[ZeroFormattable]
public class TypeA {}

[ZeroFormattable]
public class TypeB {}

Formatter.RegisterDynamicUnion<byte, string>(x =>
{
    x.Register(key: (byte)0, subType: typeof(TypeA));
    x.Register(key: (byte)1, subType: typeof(TypeB));

    return "DynamicUnionName_A"; // key of the dynamic union serializer
});

var bin = ZeroFormatterSerializer.SerializeDynamicUnion("DynamicUnionName_A", new TypeA());

// object(TypeA)
var o = ZeroFormatterSerializer.DeserializeDynamicUnion("DynamicUnionName_A", bin);

//consumer types
public class MessageBase {}
public interface IEvent{}

public class UnknownEvent : IEvent {}
[ZeroFormattable]
public class EventA : IEvent {}
[ZeroFormattable]
public class EventB : IEvent {}

public class UnknownMessage : MessageBase {}
[ZeroFormattable]
public class MessageA : MessageBase {}
[ZeroFormattable]
public class MessageB : MessageBase 
{
    [Index(0)]
    public virtual List<IEvent> Events { get; set; }
}

[ZeroFormattable]
public class MessageBatch : MessageBase 
{
    [Index(0)]
    public virtual List<MessageBase> Messages { get; set; }
}

//serialiser registration
var serialisationModel = ZeroFormatterSerializer.CreateDefaultModel()

serialisationModel.RegisterTypesWithAttributes(someAssembly);

serialisationModel.RegisterPolymorphicType<IEvent, int, UnknownEvent>(x =>
{
    //can be easily extended to reflection based scan if library consumer wants it
    x.Register(key: SomeIdGen(nameof(EventA)), subType: typeof(EventA));
    x.Register(key: SomeIdGen(nameof(EventB)), subType: typeof(EventB));
});

serialisationModel.RegisterPolymorphicType<MessageBase, int, UnknownMessage>(x =>
{
    x.Register(key: SomeIdGen(nameof(MessageA)), subType: typeof(MessageA));
    x.Register(key: SomeIdGen(nameof(MessageB)), subType: typeof(MessageB));
    x.Register(key: SomeIdGen(nameof(MessageBatch)), subType: typeof(MessageBatch));
});

MessageBase msg  = new MessageBatch { Messages = new List<MessageBase> { new MessageB { Events = new List<IEvent> { new EventA() }}};

var serialiser  = ZeroFormatterSerializer.CreateFromModel(serialisationModel);
var bts = serialiser.Serialise(msg);
var message = serialiser.Deserialise<MessageBase>(bts)

ZeroFormatterProtocolGenerator.CompileFromModel(serialisationModel, "path\UnityCompatibleProtocol.dll");

public interface ITypeResolver
{
    // can be precompiled for improve initial performance(or AOT environment).
    // precompiled generator always set to false.
    bool IsUseDefaultDynamicSerializer { get; }

    // AppendFormatterResolver in normal.
    object ResolveFormatter(Type type);

    // RegisterPolymorphicType
    object ResolveDynamicUnion(Type unionType, DynamicUnionResolver resolver);
}

public class CustomSerializationModel : ITypeResolver
{
    public bool IsUseDefaultDynamicSerializer
    {
        get
        {
            return true;
        }
    }

    public object ResolveFormatter(Type t)
    {
        return null;
    }

    public void ResolveDynamicUnion(Type unionType, DynamicUnionResolver resolver)
    {
        if (unionType == typeof(IEvent))
        {
            // resolver api is [Type, object] for reflection based regsiter(but not typesafe)
            resolver.RegisterDiscriminatedKeyType(typeof(int));
            resolver.RegisterFallbackType(typeof(UnknownEvent));
            resolver.RegisterSubType(key: SomeIdGen(nameof(EventA)), subType: typeof(EventA));
        }
        // else if...
    }
}

// chnage Formatter<T> to here
    public abstract class Formatter<TTypeResolver, T>
        where TTypeResolver : ITypeResolver, new()

// usage

// mark DynamicUnion on base type...
[DynamicUnion]
public class MessageBase {}
[DynamicUnion]
public interface IEvent{}

/// use dynamic serializer
ZeroFormatterSerializer.CustomSerializer<CustomSerializationModel>.Serialize();

// create dll
// ZeroFormatterProtocolGenerator.CompileDefault();
// ZeroFormatterProtocolGenerator.Compile<CustomSerializationModel>(IEnumerable<Type> generateTypes,string typeFullName, string path);
// ZeroFormatterProtocolGenerator.Compile<CustomSerializationModel>(IEnumerable<Assembly> scanAssemblies,string typeFullName, string path);

// use dll
// ZeroFormatterSerializer.SetDefault<GeneratedSerializationModel>();
// ZeroFormatterSerializer.Serialize();

//once on startup
var serialiser = ZeroFormatterSerializer.CustomSerializer<CustomSerializationModel>();

//many times, threadsafe
serialiser.Serialise();