. NET-serialización JSON de enum como cadena

He encontrado que Json.NET proporciona la funcionalidad exacta que estoy buscando con un atributo StringEnumConverter:

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

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

Más detalles disponibles en StringEnumConverter documentación.

Agregue lo siguiente a su global.asax para serialización JSON de enum de c# como cadena

  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 establece la serialización JSON de la enumeración de c # como cadena solo para ASP.NET (Web API y así).

Pero para que funcione también con la serialización ad hoc, agregue lo siguiente a su clase de inicio (como 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;
});

Más información sobre el Json.NET page

Además, para que su miembro enum sea serializado/deserializado hacia/desde un texto específico, use el

Sistema.Ejecución.Serialización.EnumMember

Atributo, así:

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

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

No pude cambiar el modelo de origen como en la respuesta superior (de @ob.), y no quería registrarlo globalmente como @Iggy. Así que combiné https://stackoverflow.com/a/2870420/237091 y @Iggy's https://stackoverflow.com/a/18152942/237091 para permitir la configuración del convertidor string enum durante el propio comando SerializeObject:

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

Esto se hace fácilmente agregando un ScriptIgnore atributo a la propiedad Gender, haciendo que no sea serializada, y añadiendo una propiedad GenderString que hace serializada:

class Person
{
    int Age { get; set; }

    [ScriptIgnore]
    Gender Gender { get; set; }

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

Esta versión de la respuesta de Stephen no cambia el nombre en el 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; 
        }
    }
}

Aquí está la respuesta para newtonsoft.json

enum Gender { Male, Female }

class Person
{
    int Age { get; set; }

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

Aquí hay una solución simple que serializa una enumeración C# del lado del servidor a JSON y usa el resultado para rellenar un elemento <select> del lado del cliente. Esto funciona tanto para enumeraciones simples como para enumeraciones bitflag.

He incluido la solución de extremo a extremo porque creo que la mayoría de las personas que desean serializar una enumeración de C# a JSON probablemente también la usarán para llenar un desplegable <select>.

Aquí va:

Ejemplo Enum

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

Una enumeración compleja que utiliza OR bit a bit para generar un sistema de permisos. Así que no puedes confiar en el índice simple [0,1,2..] para el valor entero de la enumeración.

Lado del servidor-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);
};

El código anterior utiliza el framework NancyFx para manejar la solicitud Get. Utiliza el método helper de Nancy Response.AsJson(), pero no se preocupe, puede usar cualquier formateador JSON estándar, ya que la enumeración ya se ha proyectado en un tipo anónimo simple listo para serialización.

JSON generado

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

Lado Del Cliente - 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 Antes de

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

HTML Después de

<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 combinación de las respuestas de Omer Bokhari y uri es siempre mi solución, ya que los valores que quiero proporcionar son generalmente diferentes de lo que tengo en mi enumeración, especialmente que me gustaría poder cambiar mis enumeraciones si lo necesito.

Así que si alguien está interesado, es algo como esto:

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

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

Puede crear JsonSerializerSettings con la llamada a JsonConverter.SerializeObject como abajo:

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

También puede agregar un convertidor a su JsonSerializer si no desea usar el atributo JsonConverter:

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

Funcionará para cada enum que vea durante esa serialización.

Para. Net Core Web Api: -

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

Notó que no hay respuesta para la serialización cuando hay un atributo Description.

Aquí está mi implementación que soporta el atributo 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");
    }
}

Enumeración:

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

Esta es una vieja pregunta, pero pensé en contribuir por si acaso. En mis proyectos utilizo modelos separados para cualquier solicitud Json. Un modelo normalmente tendría el mismo nombre que el objeto de dominio con el prefijo "Json". Los modelos se mapean usando AutoMapper . Al hacer que el modelo json declare una propiedad de cadena que es una enumeración en la clase de dominio, AutoMapper resolverá su presentación de cadena.

En caso de que se lo pregunte, necesito modelos separados para las clases serializadas Json porque serializer viene con referencias circulares de lo contrario.

Espero que esto ayude a alguien.

Puede usar un JavaScriptConverter para lograr esto con el JavaScriptSerializer incorporado. Al convertir su enumeración a un Uri, puede codificarla como una cadena.

He descrito cómo hacer esto para fechas, pero también se puede usar para enumeraciones.

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

En caso de que alguien encuentre lo anterior insuficiente, terminé conformándome con esta sobrecarga:

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

ASP.NET Camino del núcleo:

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

He reunido todas las piezas de esta solución usando la biblioteca Newtonsoft.Json. Corrige el problema de enumeración y también hace que el manejo de errores sea mucho mejor, y funciona en servicios alojados en IIS. Es bastante código, así que puedes encontrarlo en GitHub aquí: https://github.com/jongrant/wcfjsonserializer/blob/master/NewtonsoftJsonFormatter.cs

Tienes que añadir algunas entradas a tu Web.config para que funcione, puedes ver un archivo de ejemplo aqui: 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]  
);