JavaScriptSerializer - serializacja JSON wyliczenia jako łańcucha

Mam klasę, która zawiera enumwłaściwość, a po serializacji obiektu przy użyciu JavaScriptSerializermój wynik json zawiera wartość całkowitą wyliczenia, a nie jego string„nazwę”. Czy istnieje sposób, aby uzyskać wyliczenie jako stringw moim Jsonie bez konieczności tworzenia niestandardowego JavaScriptConverter? Być może istnieje atrybut, za pomocą którego mógłbym ozdobić enumdefinicję lub właściwość obiektu?

Jako przykład:

enum Gender { Male, Female }

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

Pożądany wynik JSON:

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

Idealnie szukając odpowiedzi z wbudowanymi klasami .NET, jeśli nie możliwe, mile widziane są alternatywy (takie jak Json.net).

Nie, nie ma specjalnego atrybutu, którego można użyć. JavaScriptSerializerserializuje enumsdo ich wartości liczbowych, a nie ich reprezentacji ciągu. Aby serializować nazwę enumjako nazwę zamiast wartości liczbowej, należy użyć niestandardowej serializacji .

Jeśli możesz użyć JSON.Net zamiast JavaScriptSerializerzobaczyć odpowiedź na to pytanie dostarczone przez OmerBakhari : JSON.net obejmuje ten przypadek użycia (poprzez atrybut [JsonConverter(typeof(StringEnumConverter))]) i wiele innych nieobsługiwanych przez wbudowane serializatory .net. Oto link porównujący funkcje i funkcje serializatorów .

Odkryłem, że Json.NET zapewnia dokładnie tę funkcjonalność, której szukam z StringEnumConverteratrybutem:

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

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

Więcej szczegółów dostępnych w StringEnumConverterdokumentacji .

Istnieją inne miejsca, w których można skonfigurować ten konwerter bardziej globalnie:

• samo wyliczanie, jeśli chcesz, wyliczanie zawsze jest serializowane / deserializowane jako ciąg:

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

• Jeśli ktoś chce uniknąć dekorowania atrybutów, możesz dodać konwerter do JsonSerializer (sugerowany przez Bjørn Egil ):

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

  i będzie działać dla każdego wyliczenia, które zobaczy podczas tej serializacji (sugerowane przez Travisa ).

• lub JsonConverter (sugerowany przez banana ):

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

Dodatkowo możesz kontrolować obudowę i to, czy liczby są nadal akceptowane za pomocą konstruktora StringEnumConverter (NamingStrategy, Boolean) .

Dodaj poniższy kod do pliku global.asax w celu uzyskania serializacji JSON enum c # jako łańcucha

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

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

Odpowiedź @Iggy ustawia serializację JSON wyliczenia c # jako ciąg tylko dla ASP.NET (Web API i tak dalej).

Aby jednak działał również z serializacją ad hoc, dodaj następujące elementy do swojej klasy początkowej (np. 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;
});

Więcej informacji na stronie Json.NET

Dodatkowo, aby twój członek enum szeregował / deserializował do / z określonego tekstu, użyj

System.Runtime.Serialization.EnumMember

atrybut, taki jak ten:

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

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

Nie byłem w stanie zmienić modelu źródłowego jak w górnej odpowiedzi (@ob.) I nie chciałem go rejestrować globalnie jak @Iggy. Więc połączyłem https://stackoverflow.com/a/2870420/237091 i @ Iggy's https://stackoverflow.com/a/18152942/237091, aby umożliwić skonfigurowanie konwertera wyliczania ciągów podczas samej komendy 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()
        }
    })

Kombinacja odpowiedzi Omera Bokhari i uri jest zawsze moim rozwiązaniem, ponieważ wartości, które chcę podać, zwykle różnią się od tych, które mam w swoim wyliczeniu, szczególnie że chciałbym móc zmienić moje wyliczenia, jeśli zajdzie taka potrzeba.

Jeśli więc ktoś jest zainteresowany, może to wyglądać mniej więcej tak:

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

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

Można to łatwo zrobić, dodając ScriptIgnoreatrybut do Genderwłaściwości, powodując, że nie jest ona serializowana, i dodając GenderStringwłaściwość, która jest serializowana:

class Person
{
    int Age { get; set; }

    [ScriptIgnore]
    Gender Gender { get; set; }

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

Ta wersja Stefana odpowiedź nie zmienia nazwę w 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; 
        }
    }
}

Oto odpowiedź dla newtonsoft.json

enum Gender { Male, Female }

class Person
{
    int Age { get; set; }

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

Sposób ASP.NET Core:

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

Możesz także dodać konwerter, JsonSerializerjeśli nie chcesz używać JsonConverteratrybutu:

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

Będzie działać dla każdego, enumco zobaczy podczas tej serializacji.

Oto proste rozwiązanie, które serializuje wyliczenie C # po stronie serwera do JSON i wykorzystuje wynik do wypełnienia po stronie klienta <select> elementu po . Działa to zarówno dla prostych, jak i dla bitflagów.

Zawarłem kompleksowe rozwiązanie, ponieważ myślę, że większość osób chcących serializować wyliczenie C # do JSON również prawdopodobnie użyje go do wypełnienia listy <select>rozwijanej.

Tutaj idzie:

Przykład Enum

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

Złożony wyliczenie, które wykorzystuje bitowe OR do generowania systemu uprawnień. Dlatego nie można polegać na prostym indeksie [0,1,2 ..] dla wartości całkowitej wyliczenia.

Po stronie serwera - 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);
};

Powyższy kod używa struktury NancyFX do obsługi żądania Get. Wykorzystuje NancyResponse.AsJson() metodę pomocniczą - ale nie martw się, możesz użyć dowolnego standardowego formatyzatora JSON, ponieważ wyliczenie zostało już zaprojektowane w prosty anonimowy typ gotowy do serializacji.

Wygenerowano JSON

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

Strona klienta - 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 przed

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

HTML After

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

Dla rdzenia ASP.Net Po prostu dodaj następujące elementy do klasy startowej:

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

Możesz utworzyć JsonSerializerSettings za pomocą wywołania JsonConverter.SerializeObject, jak poniżej:

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

Zauważyliśmy, że nie ma odpowiedzi na serializację, gdy istnieje atrybut Opis.

Oto moja implementacja, która obsługuje atrybut Opis.

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
}

Stosowanie:

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

Dla .Net Core: -

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

W .net core 3 jest to teraz możliwe dzięki wbudowanym klasom w 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);

Aby skonfigurować JsonStringEnumConverterz dekoracją atrybutu dla określonej właściwości:

using System.Text.Json.Serialization;

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

Jeśli chcesz zawsze konwertować wyliczenie jako ciąg, umieść atrybut w samym wyliczeniu.

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

Asp.Net Core 3 z System.Text.Json

public void ConfigureServices(IServiceCollection services)
{

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

    //...
 }

Na wypadek, gdyby ktokolwiek uznał powyższe za niewystarczające, skończyłem z tym przeciążeniem:

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

To stare pytanie, ale pomyślałem, że na wszelki wypadek. W moich projektach używam osobnych modeli dla wszystkich żądań Json. Model zazwyczaj miałby taką samą nazwę jak obiekt domeny z prefiksem „Json”. Modele są mapowane za pomocą AutoMapper . Dzięki temu, że model json deklaruje właściwość ciągu będącą wyliczeniem klasy domeny, AutoMapper rozpoznaje prezentację ciągu.

Jeśli się zastanawiasz, potrzebuję osobnych modeli dla serializowanych klas Jsona, ponieważ wbudowany serializator zawiera odwołania cykliczne.

Mam nadzieję, że to komuś pomoże.

Możesz faktycznie użyć JavaScriptConverter, aby to zrobić za pomocą wbudowanego JavaScriptSerializer. Konwertując swoje wyliczenie na Uri, możesz zakodować je jako ciąg.

Opisałem, jak to zrobić dla dat, ale można go również użyć do wyliczeń. Niestandardowy format JSON DateTime dla .NET JavaScriptSerializer .

Nie jestem pewien, czy to nadal jest istotne, ale musiałem napisać prosto do pliku JSON i wymyśliłem następujący sposób składania kilku odpowiedzi przepełnienia stosu

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

Zapewnia to, że wszystkie moje klucze json są pisane małymi literami, zgodnie z „regułami” json. Formatuje czyste wcięcie i ignoruje wartości zerowe w danych wyjściowych. Również dodając StringEnumConverter drukuje wyliczenia z ich wartością ciągu.

Osobiście uważam, że jest to najczystszy sposób, jaki mogłem wymyślić, bez konieczności brudzenia modelu adnotacjami.

stosowanie:

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

Złożyłem wszystkie elementy tego rozwiązania za pomocą Newtonsoft.Jsonbiblioteki. Rozwiązuje problem wyliczania, a także znacznie poprawia obsługę błędów i działa w usługach hostowanych w IIS. To całkiem sporo kodu, więc możesz go znaleźć na GitHub tutaj: https://github.com/jongrant/wcfjsonserializer/blob/master/NewtonsoftJsonFormatter.cs

Musisz dodać kilka wpisów do swojego Web.config, aby działało, możesz zobaczyć przykładowy plik tutaj: https://github.com/jongrant/wcfjsonserializer/blob/master/Web.config

A dla VB.net znalazłem następujące prace:

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)

Nieco bardziej przyszłościowa opcja

W obliczu tego samego pytania ustaliliśmy, że potrzebujemy niestandardowej wersji, StringEnumConverteraby upewnić się, że nasze wartości wyliczeniowe mogą się rozszerzać w czasie, nie niszcząc katastrofalnie po deserializującej stronie (patrz tło poniżej). UżywającSafeEnumConverter poniższego pozwala na zakończenie deserializacji, nawet jeśli ładunek zawiera wartość wyliczenia, która nie ma nazwanej definicji, bliżej do tego, jak działałaby konwersja zamiany na wyliczanie.

Stosowanie:

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

lub

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

Źródło:

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

tło

Kiedy spojrzeliśmy na użycie StringEnumConverter, mieliśmy problem, że potrzebowaliśmy również pasywności w przypadkach, gdy dodano nową wartość wyliczenia, ale nie każdy klient od razu wiedział o nowej wartości. W takich przypadkach StringEnumConverterpakiet z Newtonoft JSON generuje JsonSerializationExceptionbłąd podobny do „Błąd konwersji wartości SomeString na typ EnumType”, a następnie cały proces deserializacji kończy się niepowodzeniem. Było to dla nas przełomowe, ponieważ nawet jeśli klient planował zignorować / odrzucić wartość nieruchomości, której nie rozumiał, nadal musiał być zdolny do deserializacji reszty ładunku!

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