Le stockage des Enums en tant que chaînes de caractères dans MongoDB

using MongoDB.Bson;

using Newtonsoft.Json;
using Newtonsoft.Json.Converters;

public class Person
{
    [JsonConverter(typeof(StringEnumConverter))]  //JSON.Net
    [BsonRepresentation(BsonType.String)]         //Mongo
    public Gender Gender { get; set; }
}

Utilisation MemberSerializationOptionsConvention de définir une convention sur la façon dont un enum sera sauvé.

new MemberSerializationOptionsConvention(typeof(Gender), new RepresentationSerializationOptions(BsonType.String))

J'ai trouvé que l'application de Ricardo Rodriguez réponse n'est pas suffisante dans certains cas correctement sérialiser les valeurs de l'enum à la chaîne dans MongoDb:

//Set up MongoDB conventions
var pack = new ConventionPack
{
    new EnumRepresentationConvention(BsonType.String)
};

ConventionRegistry.Register("EnumStringConvention", pack, t => true);

Si votre structure de données implique des valeurs enum être enfermé dans une boîte en objets, MongoDb la sérialisation de ne pas utiliser l'ensemble EnumRepresentationConvention à sérialiser.

En effet, si vous regardez à la mise en œuvre de MongoDb du conducteur ObjectSerializer, il permettra de résoudre la TypeCode de la boîte de valeur (Int32 pour les valeurs de l'enum), et l'utilisation de ce type pour stocker votre valeur d'enum dans la base de données. Donc en boîte les valeurs de l'enum être sérialisé en tant que int valeurs. Ils resteront comme int des valeurs lors de l'être désérialisé ainsi.

Pour changer cela, il est possible d'écrire une coutume ObjectSerializer qui mettra en œuvre l'ensemble EnumRepresentationConvention si la boîte de valeur est un enum. Quelque chose comme ceci:

public class ObjectSerializer : MongoDB.Bson.Serialization.Serializers.ObjectSerializer
{
     public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, object value)
    {
        var bsonWriter = context.Writer;
        if (value != null && value.GetType().IsEnum)
        {
            var conventions = ConventionRegistry.Lookup(value.GetType());
            var enumRepresentationConvention = (EnumRepresentationConvention) conventions.Conventions.FirstOrDefault(convention => convention is EnumRepresentationConvention);
            if (enumRepresentationConvention != null)
            {
                switch (enumRepresentationConvention.Representation)
                {
                    case BsonType.String:
                        value = value.ToString();
                        bsonWriter.WriteString(value.ToString());
                        return;
                }
            }
        }

        base.Serialize(context, args, value);
    }
}

et puis définissez la coutume sérialiseur à utiliser pour la sérialisation des objets:

BsonSerializer.RegisterSerializer(typeof(object), new ObjectSerializer());

Faire cela permettra d'assurer boîte enum valeurs seront stockées sous forme de chaînes de caractères comme le "unboxed" ceux.

Gardez cependant à l'esprit que lors de la désérialisation de votre document, la boîte de la valeur restera une chaîne de caractères. Il ne sera pas converti en arrière à l'original de la valeur d'enum. Si vous avez besoin de convertir la chaîne en arrière à l'original de la valeur d'enum, une discrimination devra probablement être ajouté dans votre document afin que le sérialiseur peut savoir quel est le type enum pour desrialize dans.

Une façon de le faire serait de stocker un bfils document au lieu de simplement une chaîne de caractères, dans laquelle, en matière de discrimination (_t) et un champ de valeur (_v) serait utilisé pour stocker le type enum et de sa chaîne de valeur.

Les réponses postées ici fonctionnent bien pour TEnum et TEnum[], cependant, ne fonctionnent pas avec Dictionary<TEnum, object>. Vous pouvez obtenir ce lors de l'initialisation du processus à l'aide de code, mais je voulais le faire par des attributs. J'ai créé un flexible DictionarySerializer qui peut être configuré avec un sérialiseur pour la clé et la valeur.

public class DictionarySerializer<TDictionary, KeySerializer, ValueSerializer> : DictionarySerializerBase<TDictionary>
    where TDictionary : class, IDictionary, new()
    where KeySerializer : IBsonSerializer, new()
    where ValueSerializer : IBsonSerializer, new()
{
    public DictionarySerializer() : base(DictionaryRepresentation.Document, new KeySerializer(), new ValueSerializer())
    {
    }

    protected override TDictionary CreateInstance()
    {
        return new TDictionary();
    }
}

public class EnumStringSerializer<TEnum> : EnumSerializer<TEnum>
    where TEnum : struct
{
    public EnumStringSerializer() : base(BsonType.String) { }
}

L'utilisation de ce genre, où à la fois la clé et la valeur sont des types enum, mais pourrait être n'importe quelle combinaison de sérialiseurs:

    [BsonSerializer(typeof(DictionarySerializer<
        Dictionary<FeatureToggleTypeEnum, LicenseFeatureStateEnum>, 
        EnumStringSerializer<FeatureToggleTypeEnum>,
        EnumStringSerializer<LicenseFeatureStateEnum>>))]
    public Dictionary<FeatureToggleTypeEnum, LicenseFeatureStateEnum> FeatureSettings { get; set; }