Dictionary<string, object> zu BsonDocument Konvertierung weglassen _t-Bereich

Ist geschehen, weil Sie geben Sie object geben Sie für die Wörterbuch-Werte, sondern verwenden Sie Dictionary<string, object> geben Sie für den bestimmten Datensatz Wert. Daher, CSharp-Treiber speichert den vollständigen Namen des konkreten Typs deserialisiert werden in diesem Dokument richtig in Zukunft. Sie können auch Lesen Sie mehr über es hier: Serialisieren von Dokumenten mit der CSharp-Treiber: Polymorphe Klassen und Modulationsumwandler

Zur Erreichung des gewünschten Ergebnisses sollten Sie den konkreten Typ für die Wörterbuch-Werte:

var dictionary = new Dictionary<string, Dictionary<string, object>>
{
    { "person", new Dictionary<string, object> { { "name", "John" } } }
};
var document = dictionary.ToBsonDocument();

Gehen aus .NET-Objekte für JSON, BSON, während gleichzeitig die Vermeidung _t/_v Codierung, führt zum Verlust der Typ-Informationen für Termine und andere BSON-spezifische Typen.

Die Lösung, die ich gefunden habe für die Vermeidung _t/_v, während die Erhaltung der BSON-Arten wurde ein benutzerdefinierter Wert serializer für den Fahrer gebaut-in DictionaryInterfaceImplementerSerializer (und Optional die EnumerableInterfaceImplementerSerializer auch). Ich habe die Lösung getestet für "Erweiterte JSON-generation", d.h. JSON mit speziellen syntax für die BSON-spezifische Arten, aber das Prinzip sollte das gleiche für direkte BSON-Ausgabe.

Um dies zu tun, kopieren Sie zuerst den standard - ObjectSerializer in Ihrem C# - Projekt (und benennen Sie Sie um Unklarheiten zu vermeiden): https://github.com/mongodb/mongo-csharp-driver/blob/master/src/MongoDB.Bson/Serialization/Serializers/ObjectSerializer.cs

Neben der Klasse umbenennen, die private void SerializeDiscriminatedValue(BsonSerializationContext context, BsonSerializationArgs args, object value, Type actualType) Methode auch bearbeitet werden muss. (In meinem Fall, wollte ich auch vermeiden _t/_v Codierung für IEnumerable<object>, die sich weiter unten.)

    private void SerializeDiscriminatedValue(BsonSerializationContext context, BsonSerializationArgs args, object value, Type actualType)
    {
        var serializer = BsonSerializer.LookupSerializer(actualType);
        var polymorphicSerializer = serializer as IBsonPolymorphicSerializer;
        //Added line
        var assignableToDictionaryOrEnumerable = typeof(IDictionary<string, object>).IsAssignableFrom(actualType) || typeof(IEnumerable<object>).IsAssignableFrom(actualType);
        if (polymorphicSerializer != null && polymorphicSerializer.IsDiscriminatorCompatibleWithObjectSerializer)
        {
            serializer.Serialize(context, args, value);
        }
        else
        {
            //Edited line
            if (assignableToDictionaryOrEnumerable || (context.IsDynamicType != null && context.IsDynamicType(value.GetType())))
            {
                //We want this code to be executed for types that should be serialized without _t and _v fields
                args.NominalType = actualType;
                serializer.Serialize(context, args, value);
            }
            else
            {
                var bsonWriter = context.Writer;
                var discriminator = _discriminatorConvention.GetDiscriminator(typeof(object), actualType);

                bsonWriter.WriteStartDocument();
                bsonWriter.WriteName(_discriminatorConvention.ElementName);
                BsonValueSerializer.Instance.Serialize(context, discriminator);
                bsonWriter.WriteName("_v");
                serializer.Serialize(context, value);
                bsonWriter.WriteEndDocument();
            }
        }
    }

Unter der Annahme, dass der name der kopiert und bearbeitet-Klasse DynamicValueSerializer verwenden Sie den folgenden code, um es zu registrieren als Wert serializer beim Start der Anwendung.

BsonSerializer.RegisterSerializer(typeof(Dictionary<string, object>),
    new DictionaryInterfaceImplementerSerializer<Dictionary<string, object>, string, object>(
        DictionaryRepresentation.Document,
        new StringSerializer(),
        new DynamicValueSerializer()));

Bitte beachten Sie, dass dies getan werden muss, für jeden aktuellen Typ, deren Werte verwendet werden sollen. Der serializer-Registrierung kann nicht getan werden für die Schnittstellen. Also, wenn SortedDictionary<string, object> oder SortedList<string, object> behandelt werden in der gleichen Weise wie Dictionary<string, object> die Registrierung muss wiederholt werden, für diese Arten. (Dies beeinflusst, ob Wörterbücher enthaltenen Werte in Sammlungen dieser Typen wird serialisiert werden, ohne _t/_v, nicht unbedingt, ob die Objekte von den Typen, die sich selbst serialisiert in dieser Art und Weise.)

Gelten die gleichen Serialisierung Prinzip List<object> Objekte, verwenden Sie den folgenden Registrierungscode.

BsonSerializer.RegisterSerializer(typeof(List<object>),
    new EnumerableInterfaceImplementerSerializer<List<object>, object>(
        new DynamicValueSerializer()));