[c#] Sérialisation JSON d'enum sous forme de chaîne



Answers

J'ai trouvé que Json.NET fournit la fonctionnalité exacte que je recherche avec un attribut StringEnumConverter :

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

[JsonConverter(typeof(StringEnumConverter))]
public Gender Gender { get; set; }

Plus de détails disponibles sur la documentation StringEnumConverter .

Question

J'ai une classe qui contient une propriété enum , et lors de la sérialisation de l'objet en utilisant JavaScriptSerializer , mon résultat json contient la valeur entière de l'énumération plutôt que sa string "nom". Y at-il un moyen d'obtenir l'enum comme une string dans mon json sans avoir à créer un JavaScriptConverter personnalisé? Peut-être y at-il un attribut que je pourrais décorer avec la définition enum , ou la propriété de l'objet?

Par exemple:

enum Gender { Male, Female }

class Person
{
    int Age { get; set; }
    Gender Gender { get; set; }
}

Résultat json désiré:

{ "Age": 35, "Gender": "Male" }



La combinaison d'Omer Bokhari et des réponses d'Uri est toujours ma solution puisque les valeurs que je veux fournir sont généralement différentes de ce que j'ai dans mon énumération, spécialement que j'aimerais pouvoir changer mes énumérations si j'en ai besoin.

Donc, si quelqu'un est intéressé, c'est quelque chose comme ça:

public enum Gender
{
   [EnumMember(Value = "male")] 
   Male,
   [EnumMember(Value = "female")] 
   Female
}

class Person
{
    int Age { get; set; }
    [JsonConverter(typeof(StringEnumConverter))]
    Gender Gender { get; set; }
}



Je n'ai pas été capable de changer le modèle source comme dans la meilleure réponse (de @ob.), Et je ne voulais pas l'enregistrer globalement comme @Iggy. J'ai donc combiné https://.com/a/2870420/237091 et @ https://.com/a/18152942/237091 d'Iggy pour permettre la mise en place du convertisseur de chaîne enum pendant la commande SerializeObject elle-même:

Newtonsoft.Json.JsonConvert.SerializeObject(
    objectToSerialize, 
    Newtonsoft.Json.Formatting.None, 
    new Newtonsoft.Json.JsonSerializerSettings()
    {
        Converters = new List<Newtonsoft.Json.JsonConverter> {
            new Newtonsoft.Json.Converters.StringEnumConverter()
        }
    })



Vous pouvez réellement utiliser un JavaScriptConverter pour accomplir ceci avec JavaScriptSerializer intégré. En convertissant votre énumération en Uri, vous pouvez l'encoder sous forme de chaîne.

J'ai décrit comment faire cela pour les dates mais il peut aussi être utilisé pour les énumérations.

http://blog.calyptus.eu/seb/2011/12/custom-datetime-json-serialization/




Vous pouvez créer JsonSerializerSettings avec l'appel à JsonConverter.SerializeObject comme ci-dessous:

var result = JsonConvert.SerializeObject
            (
                dataObject,
                new JsonSerializerSettings
                {
                    Converters = new [] {new StringEnumConverter()}
                }
            );



J'ai rassemblé toutes les pièces de cette solution en utilisant la bibliothèque Newtonsoft.Json . Il corrige le problème enum et améliore également la gestion des erreurs, et cela fonctionne dans les services hébergés IIS. C'est beaucoup de code, donc vous pouvez le trouver sur GitHub ici: https://github.com/jongrant/wcfjsonserializer/blob/master/NewtonsoftJsonFormatter.cs

Vous devez ajouter quelques entrées à votre Web.config pour le faire fonctionner, vous pouvez voir un exemple de fichier ici: https://github.com/jongrant/wcfjsonserializer/blob/master/Web.config




Remarqué qu'il n'y a pas de réponse pour la sérialisation quand il y a un attribut Description.

Voici mon implémentation qui supporte l'attribut Description.

public class CustomStringEnumConverter : Newtonsoft.Json.Converters.StringEnumConverter
{
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        Type type = value.GetType() as Type;

        if (!type.IsEnum) throw new InvalidOperationException("Only type Enum is supported");
        foreach (var field in type.GetFields())
        {
            if (field.Name == value.ToString())
            {
                var attribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
                writer.WriteValue(attribute != null ? attribute.Description : field.Name);

                return;
            }
        }

        throw new ArgumentException("Enum not found");
    }
}

Enum:

public enum FooEnum
{
    // Will be serialized as "Not Applicable"
    [Description("Not Applicable")]
    NotApplicable,

    // Will be serialized as "Applicable"
    Applicable
}

Usage:

[JsonConverter(typeof(CustomStringEnumConverter))]
public FooEnum test { get; set; }



Voici la réponse pour newtonsoft.json

enum Gender { Male, Female }

class Person
{
    int Age { get; set; }

    [JsonConverter(typeof(StringEnumConverter))]
    Gender Gender { get; set; }
}



La réponse @Iggy définit la sérialisation JSON de c # enum en tant que chaîne uniquement pour ASP.NET (API Web et ainsi de suite).

Mais pour que cela fonctionne aussi avec une sérialisation ad hoc, ajoutez les suivantes à votre classe de démarrage (comme Global.asax Application_Start)

//convert Enums to Strings (instead of Integer) globally
JsonConvert.DefaultSettings = (() =>
{
    var settings = new JsonSerializerSettings();
    settings.Converters.Add(new StringEnumConverter { CamelCaseText = true });
    return settings;
});

Plus d'informations sur la page Json.NET

De plus, pour que votre membre enum puisse sérialiser / désérialiser vers / depuis un texte spécifique, utilisez le

System.Runtime.Serialization.EnumMember

attribut, comme ceci:

public enum time_zone_enum
{
    [EnumMember(Value = "Europe/London")] 
    EuropeLondon,

    [EnumMember(Value = "US/Alaska")] 
    USAlaska
}





Related