.NET - la sérialisation JSON de enum comme une chaîne de caractères

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

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

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

plus de détails sur StringEnumConverter documentation .

ajoutez ce qui suit à votre global.asax pour la sérialisation JSON en c# enum en tant que chaîne de caractères

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

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

@Iggy answer sets JSON serialization of c# enum as string only for ASP.NET (API Web et so).

mais pour que cela fonctionne aussi avec la sérialisation ad hoc, ajoutez la suite à votre classe start (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'information sur le Json.NET page

de plus, pour que votre membre enum sérialise/désérialise à partir d'un texte spécifique, utilisez le

Système

.Runtime.Sérialisation.EnumMember

attribut, comme ceci:

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

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

Je n'ai pas pu changer le modèle source comme dans la réponse du haut (de @ob.), et je ne voulais pas l'enregistrer globalement comme @Iggy. Donc j'ai combiné https://stackoverflow.com/a/2870420/237091 et de @Iggy https://stackoverflow.com/a/18152942/237091 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()
        }
    })

cela se fait facilement en ajoutant un attribut ScriptIgnore à la propriété Gender , ce qui la rend non sérialisée, et en ajoutant une propriété GenderString qui fait obtenir sérialisée:

class Person
{
    int Age { get; set; }

    [ScriptIgnore]
    Gender Gender { get; set; }

    string GenderString { get { return Gender.ToString(); } }
}

Cette version de Stephen réponse ne pas modifier 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; 
        }
    }
}

Voici la réponse pour newtonsoft.json

enum Gender { Male, Female }

class Person
{
    int Age { get; set; }

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

Voici une solution simple qui sérialise un C# enum côté serveur vers JSON et utilise le résultat pour peupler un élément <select> côté client. Cela fonctionne pour les deux enums simples et bitflag enums.

j'ai inclus la solution de bout en bout parce que je pense que la plupart des gens qui veulent sérialiser un C# enum à JSON l'utiliseront probablement aussi pour remplir un <select> drop-down.

va Ici:

exemple Enum

public enum Role
{
    None = Permission.None,
    Guest = Permission.Browse,
    Reader = Permission.Browse| Permission.Help ,
    Manager = Permission.Browse | Permission.Help | Permission.Customise
}

un enum complexe qui utilise des ORs bitwise pour générer un système de permissions. Donc, vous ne pouvez pas compter sur le simple index [0,1,2..] pour la valeur entière de l'enum.

Côté Serveur - C#

Get["/roles"] = _ =>
{
    var type = typeof(Role);
    var data = Enum
        .GetNames(type)
        .Select(name => new 
            {
                Id = (int)Enum.Parse(type, name), 
                Name = name 
            })
        .ToArray();

    return Response.AsJson(data);
};

le code ci-dessus utilise le framework NancyFX pour gérer la requête Get. Il utilise la méthode D'aide Response.AsJson() de Nancy - mais ne vous inquiétez pas, vous pouvez utiliser n'importe quel JSON standard formater comme l'enum a déjà été projeté dans un type anonyme simple prêt pour la sérialisation.

a Généré JSON

[
    {"Id":0,"Name":"None"},
    {"Id":2097155,"Name":"Guest"},
    {"Id":2916367,"Name":"Reader"},
    {"Id":4186095,"Name":"Manager"}
]

Côté Client-CoffeeScript

fillSelect=(id, url, selectedValue=0)->
    $select = $ id
    $option = (item)-> $ "<option/>", 
        {
            value:"#{item.Id}"
            html:"#{item.Name}"
            selected:"selected" if item.Id is selectedValue
        }
    $.getJSON(url).done (data)->$option(item).appendTo $select for item in data

$ ->
    fillSelect "#role", "/roles", 2916367

HTML avant

<select id="role" name="role"></select>

HTML après

<select id="role" name="role">
    <option value="0">None</option>
    <option value="2097155">Guest</option>
    <option value="2916367" selected="selected">Reader</option>
    <option value="4186095">Manager</option>
</select>

la combinaison des réponses D'Omer Bokhari et uri est également ma solution puisque les valeurs que je veux fournir est généralement différent de ce que j'ai dans mon enum spécialement que je voudrais être en mesure de changer mes enums si j'ai besoin.

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

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

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

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

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

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

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

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

Pour L'Api Web De .Net Core: -

public void ConfigureServices(IServiceCollection services)
{
    ...
    services.AddJsonFormatters(f => f.Converters.Add(new StringEnumConverter()));
    ...
}

a remarqué qu'il n'y a pas de réponse pour la sérialisation lorsqu'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
}

Utilisation:

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

c'est une vieille question mais j'ai pensé que je pourrais contribuer juste au cas où. Dans mes projets, j'utilise des modèles séparés pour toutes les requêtes Json. Un modèle aurait généralement le même nom que l'objet du domaine avec le préfixe "Json". Les modèles sont mappés en utilisant AutoMapper . En ayant le modèle JSON déclarer une propriété de chaîne de caractères qui est un enum sur la classe de domaine, AutoMapper résoudra à sa présentation de chaîne de caractères.

Dans le cas où vous vous demandez, j'ai besoin de modèles séparés pour Json sérialisé cours parce intégré sérialiseur vient avec des références circulaires autrement.

J'espère que ça aidera quelqu'un.

vous pouvez réellement utiliser un JavaScriptConverter pour accomplir cela avec le JavaScriptSerializer intégré. En convertissant votre enum en Uri, vous pouvez l'encoder comme une chaîne.

, j'ai décrit comment faire pour les dates, mais il peut être utilisé pour les énumérations.

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

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

ASP.NET Core way:

public class Startup
{
  public IServiceProvider ConfigureServices(IServiceCollection services)
  {
    services.AddMvc().AddJsonOptions(options =>
    {
      options.SerializerSettings.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter());
    });
  }
}

https://gist.github.com/regisdiogo/27f62ef83a804668eb0d9d0f63989e3e

j'ai assemblé toutes les pièces de cette solution en utilisant la bibliothèque Newtonsoft.Json . Il corrige le problème d'enum et améliore également la gestion des erreurs, et fonctionne dans les services hébergés par 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 des entrées à votre Web.config pour le faire fonctionner, vous pouvez voir une exemple de fichier ici: https://github.com/jongrant/wcfjsonserializer/blob/master/Web.config

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]  
);