serialize - stringenumconverter c# example




Sérialisation JSON d'enum sous forme de chaîne (13)

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" }

Ajoutez ci-dessous à votre global.asax pour la sérialisation JSON de c # enum sous forme de chaîne

  HttpConfiguration config = GlobalConfiguration.Configuration;
            config.Formatters.JsonFormatter.SerializerSettings.Formatting =
                Newtonsoft.Json.Formatting.Indented;

            config.Formatters.JsonFormatter.SerializerSettings.Converters.Add
                (new Newtonsoft.Json.Converters.StringEnumConverter());

C'est une vieille question mais je pensais que je contribuerais au cas où. Dans mes projets, j'utilise des modèles séparés pour toutes les demandes JSON. Un modèle aurait généralement le même nom que l'objet domaine avec le préfixe "Json". Les modèles sont mappés à l'aide d' AutoMapper . En ayant le modèle json déclare une propriété de chaîne qui est une énumération sur la classe de domaine, AutoMapper résoudra à sa présentation de chaîne.

Dans le cas où vous vous posez la question, j'ai besoin de modèles séparés pour les classes sérialisées Json, car le sérialiseur intégré contient des références circulaires.

J'espère que cela aide quelqu'un.


Cette version de la answer de Stephen ne change pas le nom dans le JSON:

[DataContract(
    Namespace = 
       "http://schemas.datacontract.org/2004/07/Whatever")]
class Person
{
    [DataMember]
    int Age { get; set; }

    Gender Gender { get; set; }

    [DataMember(Name = "Gender")]
    string GenderString
    {
        get { return this.Gender.ToString(); }
        set 
        { 
            Gender g; 
            this.Gender = Enum.TryParse(value, true, out g) ? g : Gender.Male; 
        }
    }
}

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


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()
        }
    })

Juste au cas où quelqu'un trouverait ce qui précède insuffisant, j'ai fini par régler avec cette surcharge:

JsonConvert.SerializeObject(objToSerialize, Formatting.Indented, new Newtonsoft.Json.Converters.StringEnumConverter())

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
}

Non, il n'y a pas d'attribut spécial que vous pouvez utiliser. JavaScriptSerializer sérialise les enums à leurs valeurs numériques et non leur représentation sous forme de chaîne. Vous auriez besoin d'utiliser la sérialisation personnalisée pour sérialiser l' enum comme nom au lieu de la valeur numérique.

Edit: Comme indiqué par @OmerBakhari JSON.net couvre ce cas d'utilisation (via l'attribut [JsonConverter(typeof(StringEnumConverter))] ) et beaucoup d'autres ne sont pas gérés par les sérialiseurs .net intégrés. Voici un lien comparant les fonctionnalités et les fonctionnalités des sérialiseurs .


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; }
}

Vous pouvez également ajouter un convertisseur à votre JsonSerializer si vous ne voulez pas utiliser l'attribut JsonConverter :

string SerializedResponse = JsonConvert.SerializeObject(
     objToSerialize, 
     new Newtonsoft.Json.Converters.StringEnumConverter()
); 

Il fonctionnera pour chaque enum qu'il voit pendant cette sérialisation.


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

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

new JavaScriptSerializer().Serialize(  
    (from p   
    in (new List<Person>() {  
        new Person()  
        {  
            Age = 35,  
            Gender = Gender.Male  
        }  
    })  
    select new { Age =p.Age, Gender=p.Gender.ToString() }  
    ).ToArray()[0]  
);






javascriptserializer