JavaScriptSerializer - serializzazione JSON di enum come stringa

Ho una classe che contiene una enumproprietà e, quando serializzo l'oggetto usando JavaScriptSerializer, il mio risultato json contiene il valore intero dell'enumerazione anziché il suo string"nome". C'è un modo per ottenere l'enum come un stringnel mio json senza dover creare un'abitudine JavaScriptConverter? Forse c'è un attributo con cui potrei decorare la enumdefinizione o la proprietà dell'oggetto?

Come esempio:

enum Gender { Male, Female }

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

Risultato json desiderato:

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

Idealmente in cerca di risposta con le classi .NET framework integrate, se non possibili alternative (come Json.net) sono i benvenuti.

No, non è possibile utilizzare alcun attributo speciale. JavaScriptSerializerserializza i enumsloro valori numerici e non la loro rappresentazione in forma di stringa. Dovresti utilizzare la serializzazione personalizzata per serializzare il enumnome come anziché il valore numerico.

Se puoi usare JSON.Net invece di JavaScriptSerializervedere la risposta a questa domanda fornita da OmerBakhari : JSON.net tratta questo caso d'uso (tramite l'attributo [JsonConverter(typeof(StringEnumConverter))]) e molti altri non gestiti dai serializzatori .net integrati. Ecco un link che confronta le caratteristiche e le funzionalità dei serializzatori .

Ho scoperto che Json.NET fornisce la funzionalità esatta che sto cercando con un StringEnumConverterattributo:

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

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

Maggiori dettagli sono disponibili sulla StringEnumConverterdocumentazione .

Esistono altri posti per configurare questo convertitore in modo più globale:

• enum stesso se vuoi che enum sia sempre serializzato / deserializzato come stringa:

  [JsonConverter(typeof(StringEnumConverter))]  
  enum Gender { Male, Female }

• Nel caso in cui qualcuno desideri evitare la decorazione degli attributi, puoi aggiungere il convertitore al tuo JsonSerializer (suggerito da Bjørn Egil ):

  serializer.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter()); 

  e funzionerà per ogni enum che vede durante quella serializzazione (suggerito da Travis ).

• o JsonConverter (suggerito da banana ):

  JsonConvert.SerializeObject(MyObject, 
      new Newtonsoft.Json.Converters.StringEnumConverter());

Inoltre puoi controllare il case e se i numeri sono ancora accettati usando il costruttore StringEnumConverter (NamingStrategy, Boolean) .

Aggiungi quanto segue a global.asax per la serializzazione JSON di c # enum come stringa

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

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

La risposta @Iggy imposta la serializzazione JSON di c # enum come stringa solo per ASP.NET (API Web e così).

Ma per farlo funzionare anche con la serializzazione ad hoc, aggiungi il seguito alla tua classe iniziale (come 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;
});

Maggiori informazioni sulla pagina Json.NET

Inoltre, per fare in modo che il tuo membro enum serializzi / deserializzi da / verso testo specifico, usa il

System.Runtime.Serialization.EnumMember

attributo, in questo modo:

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

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

Non sono stato in grado di cambiare il modello sorgente come nella risposta in alto (di @ob.) E non volevo registrarlo a livello globale come @Iggy. Quindi ho combinato https://stackoverflow.com/a/2870420/237091 e @ Iggy https://stackoverflow.com/a/18152942/237091 per consentire l'impostazione del convertitore enum stringa durante il comando SerializeObject stesso:

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

La combinazione delle risposte di Omer Bokhari e di uri è sempre la mia soluzione poiché i valori che voglio fornire sono di solito diversi da quelli che ho nel mio enum specialmente che vorrei poter cambiare i miei enum se ne avessi bisogno.

Quindi, se qualcuno è interessato, è qualcosa del genere:

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

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

Questo è fatto facilmente con l'aggiunta di un ScriptIgnoreattributo al Genderproprietà, inducendolo a non essere serializzato, e l'aggiunta di una GenderStringproprietà che non ottenere serializzato:

class Person
{
    int Age { get; set; }

    [ScriptIgnore]
    Gender Gender { get; set; }

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

Questa versione della risposta di Stephen non cambia il nome in 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; 
        }
    }
}

Ecco la risposta per newtonsoft.json

enum Gender { Male, Female }

class Person
{
    int Age { get; set; }

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

Modo Core ASP.NET:

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

Puoi anche aggiungere un convertitore al tuo JsonSerializerse non vuoi usare l' JsonConverterattributo:

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

Funzionerà per tutto enumciò che vede durante quella serializzazione.

Ecco una semplice soluzione che serializza un enum C # lato server su JSON e utilizza il risultato per popolare un <select>elemento lato client . Funziona sia con enumerazioni semplici che con bitflag.

Ho incluso la soluzione end-to-end perché penso che la maggior parte delle persone che vogliono serializzare un enumerazione C # su JSON probabilmente la useranno anche per compilare un <select>menu a discesa.

Ecco qui:

Esempio Enum

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

Un enum complesso che utilizza OR bit per bit per generare un sistema di autorizzazioni. Quindi non puoi fare affidamento sul semplice indice [0,1,2 ..] per il valore intero dell'enum.

Lato server - 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);
};

Il codice sopra utilizza il framework NancyFX per gestire la richiesta Get. Utilizza il Response.AsJson()metodo helper di Nancy, ma non preoccuparti, puoi usare qualsiasi formattatore JSON standard poiché l'enum è già stato proiettato in un semplice tipo anonimo pronto per la serializzazione.

JSON generato

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

Lato 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 prima

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

HTML dopo

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

Per il core ASP.Net Basta aggiungere quanto segue alla Classe di avvio:

JsonConvert.DefaultSettings = (() =>
        {
            var settings = new JsonSerializerSettings();
            settings.Converters.Add(new StringEnumConverter { AllowIntegerValues = false });
            return settings;
        });

È possibile creare JsonSerializerSettings con la chiamata a JsonConverter.SerializeObject come di seguito:

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

Si è notato che non esiste una risposta per la serializzazione in presenza di un attributo Descrizione.

Ecco la mia implementazione che supporta l'attributo Descrizione.

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
}

Uso:

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

Per .Net Core: -

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

In .net core 3 questo è ora possibile con le classi integrate in System.Text.Json:

var person = new Person();
// Create and add a converter which will use the string representation instead of the numeric value.
var stringEnumConverter = new System.Text.Json.Serialization.JsonStringEnumConverter();
JsonSerializerOptions opts = new JsonSerializerOptions();
opts.Converters.Add(stringEnumConverter);
// Generate json string.
var json = JsonSerializer.Serialize<Person>(person, opts);

Per configurare JsonStringEnumConvertercon la decorazione degli attributi per la proprietà specifica:

using System.Text.Json.Serialization;

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

Se vuoi convertire sempre l'enum come stringa, metti l'attributo sull'enum stesso.

[JsonConverter(typeof(JsonStringEnumConverter))] 
enum Gender { Male, Female }

Asp.Net Core 3 con System.Text.Json

public void ConfigureServices(IServiceCollection services)
{

    services
        .AddControllers()
        .AddJsonOptions(options => 
           options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter())
        );

    //...
 }

Nel caso in cui qualcuno trova insufficiente quanto sopra, ho finito per accontentarmi di questo sovraccarico:

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

Questa è una vecchia domanda ma ho pensato di contribuire per ogni evenienza. Nei miei progetti utilizzo modelli separati per qualsiasi richiesta Json. Un modello in genere avrebbe lo stesso nome dell'oggetto dominio con prefisso "Json". I modelli vengono mappati utilizzando AutoMapper . Avendo il modello json di dichiarare una proprietà stringa che è un enum sulla classe di dominio, AutoMapper risolverà la sua presentazione di stringa.

Nel caso ve lo stiate chiedendo, ho bisogno di modelli separati per le classi serializzate Json perché altrimenti il ​​serializzatore integrato presenta riferimenti circolari.

Spero che questo aiuti qualcuno.

Puoi effettivamente utilizzare un JavaScriptConverter per farlo con JavaScriptSerializer integrato. Convertendo il tuo enum in un Uri puoi codificarlo come una stringa.

Ho descritto come farlo per le date, ma può essere usato anche per gli enum. Formato JSON DateTime personalizzato per .NET JavaScriptSerializer .

Non sono sicuro se questo è ancora rilevante, ma ho dovuto scrivere direttamente in un file JSON e ho trovato il seguente mettendo insieme diverse risposte stackoverflow insieme

public class LowercaseJsonSerializer
{
    private static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
    {
        ContractResolver = new LowercaseContractResolver()
    };

    public static void Serialize(TextWriter file, object o)
    {
        JsonSerializer serializer = new JsonSerializer()
        {
            ContractResolver = new LowercaseContractResolver(),
            Formatting = Formatting.Indented,
            NullValueHandling = NullValueHandling.Ignore
        };
        serializer.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter());
        serializer.Serialize(file, o);
    }

    public class LowercaseContractResolver : DefaultContractResolver
    {
        protected override string ResolvePropertyName(string propertyName)
        {
            return Char.ToLowerInvariant(propertyName[0]) + propertyName.Substring(1);
        }
    }
}

Assicura che tutte le mie chiavi json siano minuscole a partire dalle "regole" json. Formatta il rientro in modo chiaro e ignora i null nell'output. Inoltre, aggiungendo un StringEnumConverter, stampa gli enum con il loro valore di stringa.

Personalmente trovo che sia il più pulito che potrei inventare, senza dover sporcare il modello con le annotazioni.

utilizzo:

    internal void SaveJson(string fileName)
    {
        // serialize JSON directly to a file
        using (StreamWriter file = File.CreateText(@fileName))
        {
            LowercaseJsonSerializer.Serialize(file, jsonobject);
        }
    }

Ho messo insieme tutti i pezzi di questa soluzione usando la Newtonsoft.Jsonlibreria. Risolve il problema enum e migliora notevolmente la gestione degli errori e funziona nei servizi ospitati da IIS. È un sacco di codice, quindi puoi trovarlo su GitHub qui: https://github.com/jongrant/wcfjsonserializer/blob/master/NewtonsoftJsonFormatter.cs

Devi aggiungere alcune voci al tuo Web.configper farlo funzionare, puoi vedere un file di esempio qui: https://github.com/jongrant/wcfjsonserializer/blob/master/Web.config

E per VB.net ho trovato i seguenti lavori:

Dim sec = New Newtonsoft.Json.Converters.StringEnumConverter()
sec.NamingStrategy() = New Serialization.CamelCaseNamingStrategy

Dim JSON_s As New JsonSerializer
JSON_s.Converters.Add(sec)

Dim jsonObject As JObject
jsonObject = JObject.FromObject(SomeObject, JSON_s)
Dim text = jsonObject.ToString

IO.File.WriteAllText(filePath, text)

Un'opzione leggermente più a prova di futuro

Di fronte alla stessa domanda, abbiamo stabilito che avevamo bisogno di una versione personalizzata di StringEnumConverterper assicurarci che i nostri valori enum potessero espandersi nel tempo senza rompersi catastroficamente sul lato deserializzante (vedi sfondo sotto). Usando ilSafeEnumConverter segue consente di terminare la deserializzazione anche se il payload contiene un valore per l'enum che non ha una definizione con nome, più vicino a come funzionerebbe la conversione da int-en-enum.

Uso:

[SafeEnumConverter]
public enum Colors
{
    Red,
    Green,
    Blue,
    Unsupported = -1
}

o

[SafeEnumConverter((int) Colors.Blue)]
public enum Colors
{
    Red,
    Green,
    Blue
}

Fonte:

public class SafeEnumConverter : StringEnumConverter
{
    private readonly int _defaultValue;

    public SafeEnumConverter()
    {
        // if you've been careful to *always* create enums with `0` reserved
        // as an unknown/default value (which you should), you could use 0 here. 
        _defaultValue = -1;
    }

    public SafeEnumConverter(int defaultValue)
    {
        _defaultValue = defaultValue;
    }

    /// <summary>
    /// Reads the provided JSON and attempts to convert using StringEnumConverter. If that fails set the value to the default value.
    /// </summary>
    /// <returns>The deserialized value of the enum if it exists or the default value if it does not.</returns>
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        try
        {
            return base.ReadJson(reader, objectType, existingValue, serializer);
        }
        catch
        {
            return Enum.Parse(objectType, $"{_defaultValue}");
        }
    }

    public override bool CanConvert(Type objectType)
    {
        return base.CanConvert(objectType) && objectType.GetTypeInfo().IsEnum;
    }
}

sfondo

Quando abbiamo esaminato l'utilizzo di StringEnumConverter, il problema che abbiamo riscontrato è che avevamo anche bisogno di passività per i casi in cui veniva aggiunto un nuovo valore enum, ma non tutti i client erano immediatamente a conoscenza del nuovo valore. In questi casi, il StringEnumConverterpacchetto con Newtonsoft JSON genera un JsonSerializationExceptionsimile a "Errore durante la conversione del valore SomeString in tipo EnumType" e quindi l' intero processo di deserializzazione ha esito negativo. Per noi è stato un grosso problema, perché anche se il cliente avesse pianificato di ignorare / scartare il valore della proprietà che non capiva, doveva comunque essere in grado di deserializzare il resto del payload!

        Person p = new Person();
        p.Age = 35;
        p.Gender = Gender.Male;
        //1.  male="Male";
        string male = Gender.Male.ToString();

        p.Gender = Gender.Female;

        //2.  female="Female";
        string female = Enum.GetName(typeof(Gender), p.Gender);

        JObject jobj = new JObject();
        jobj["Age"] = p.Age;
        jobj["Gender"] = male;
        jobj["Gender2"] = female;

        //you result:  josn= {"Age": 35,"Gender": "Male","Gender2": "Female"}
        string json = jobj.ToString();

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