Customize how _type is handled

Currently the _type property always contains the assembly qualified name of the type. This means that if something changes between versions (e.g. an assembly or type is renamed), existing document can no longer be deserialized.

Is there a way to use custom type/name mappings instead? From what I see in the code, I don’t think so, but it would be a useful addition.

JSON.NET offers an extension point for this: the ISerializationBinder interface, which lets you map a type to a name and vice versa. Is this something you’d consider adding to LiteDB? It would be very useful to make it easier to evolve apps with existing data.

[thomaslevesque]

Is there any documentation on how to use this?

I don’t think so, but it’s pretty simple. Just pass a BsonMapper with your custom type name binder to the LiteDatabase ctor:

class MyCustomTypeBinder : ITypeNameBinder
{
    public string GetName(Type type)
    {
        // TODO
    }

    public Type GetType(string name)
    {
        // TODO
    }
}

using var db = new LiteDatabase(path, new BsonMapper(new MyCustomTypeBinder));

I’m looking for the ability with polymorphic docs to ignore documents where _type does not resolve to a loaded assembly. I was wondering if this might help me.

I’m not sure it could help for this scenario…

[tjmoore]

That actually works. Implementing GetName the same as the default, and GetType returns the base class type on matching a condition. In my case I’m looking at the name containing certain words I know all my derived types have, which suits my needs. Anything else is null and reverts to throwing error.

Deserialise then returns instances of the base class, obviously ignoring properties from the derived. That’s okay for what I need.

class MyCustomTypeBinder : ITypeNameBinder
{
    public string GetName(Type type) => type.FullName + ", " + type.GetTypeInfo().Assembly.GetName().Name;

    public Type GetType(string name)
    {
        // GetType without exception
        Type type = Type.GetType(name, false);
        if (type != null)
            return type;

        // Unknown type, but return base if a condition matches
        if (... SOME CONDITION ...)
            return typeof(MyBaseClass);

        // Otherwise null
        return null;
    }
}