JavaScriptSerializer - serialisasi JSON dari enum sebagai string

Saya memiliki kelas yang berisi enumproperti, dan setelah serialisasi objek menggunakan JavaScriptSerializer, hasil json saya berisi nilai integer enumerasi daripada string"namanya". Apakah ada cara untuk mendapatkan enum sebagai stringdi json saya tanpa harus membuat kebiasaan JavaScriptConverter? Mungkin ada atribut yang saya dapat menghias enumdefinisi, atau properti objek, dengan?

Sebagai contoh:

enum Gender { Male, Female }

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

Hasil json yang diinginkan:

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

Idealnya mencari jawaban dengan built-in kelas .NET framework, jika tidak memungkinkan alternatif (seperti Json.net) dipersilakan.

Tidak, tidak ada atribut khusus yang dapat Anda gunakan. JavaScriptSerializercerita bersambung enumske nilai numerik mereka dan bukan representasi string mereka. Anda perlu menggunakan serialisasi khusus untuk membuat serialisasi enumsebagai namanya alih-alih nilai numerik.

Jika Anda dapat menggunakan JSON.Net JavaScriptSerializerdaripada melihat jawaban pada pertanyaan ini yang disediakan oleh OmerBakhari : JSON.net membahas use case ini (melalui atribut [JsonConverter(typeof(StringEnumConverter))]) dan banyak lainnya yang tidak ditangani oleh serializers .net yang dibangun. Berikut ini tautan yang membandingkan fitur dan fungsi serialis .

Saya telah menemukan bahwa Json.NET menyediakan fungsionalitas tepat yang saya cari dengan StringEnumConverteratribut:

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

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

Lebih detail tersedia di StringEnumConverterdokumentasi .

Ada tempat lain untuk mengkonfigurasi konverter ini secara lebih global:

• enum sendiri jika Anda ingin enum selalu serial / deserialized sebagai string:

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

• Jika ada yang ingin menghindari dekorasi atribut, Anda dapat menambahkan konverter ke JsonSerializer Anda (disarankan oleh Bjørn Egil ):

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

  dan itu akan bekerja untuk setiap enum yang dilihatnya selama serialisasi itu (disarankan oleh Travis ).

• atau JsonConverter (disarankan oleh pisang ):

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

Selain itu Anda dapat mengontrol casing dan apakah nomor masih diterima dengan menggunakan konstruktor StringEnumConverter (NamingStrategy, Boolean) .

Tambahkan di bawah ini ke global.asax Anda untuk serialisasi JSON dari c # enum sebagai string

  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 menetapkan serialisasi JSON dari c # enum sebagai string hanya untuk ASP.NET (API Web dan sebagainya).

Tetapi untuk membuatnya bekerja juga dengan serialisasi ad hoc, tambahkan berikut ke kelas awal Anda (seperti 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;
});

Informasi lebih lanjut tentang halaman Json.NET

Selain itu, untuk meminta anggota enum Anda membuat cerita bersambung / deserialize ke / dari teks tertentu, gunakan

System.Runtime.Serialization.EnumMember

atribut, seperti ini:

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

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

Saya tidak dapat mengubah model sumber seperti pada jawaban teratas (dari @ob.), Dan saya tidak ingin mendaftarkannya secara global seperti @Iggy. Jadi saya menggabungkan https://stackoverflow.com/a/2870420/237091 dan @ Iggy's https://stackoverflow.com/a/18152942/237091 untuk memungkinkan pengaturan konverter string pada saat perintah SerializeObject itu sendiri:

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

Kombinasi jawaban Omer Bokhari dan uri adalah selalu merupakan solusi saya karena nilai yang ingin saya berikan biasanya berbeda dari apa yang saya miliki di enum saya khususnya bahwa saya ingin dapat mengubah enum saya jika saya perlu.

Jadi, jika ada yang tertarik, ini adalah sesuatu seperti ini:

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

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

Hal ini mudah dilakukan dengan menambahkan ScriptIgnoreatribut ke Genderproperti, menyebabkan ia tidak serial, dan menambahkan GenderStringproperti yang tidak mendapatkan serial:

class Person
{
    int Age { get; set; }

    [ScriptIgnore]
    Gender Gender { get; set; }

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

Versi jawaban Stephen ini tidak mengubah nama di 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; 
        }
    }
}

Inilah jawaban untuk newtonsoft.json

enum Gender { Male, Female }

class Person
{
    int Age { get; set; }

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

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

Anda juga dapat menambahkan konverter ke Anda JsonSerializerjika Anda tidak ingin menggunakan JsonConverteratribut:

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

Ini akan bekerja untuk setiap enumyang dilihatnya selama serialisasi itu.

Berikut ini adalah solusi sederhana yang membuat serial C-enum sisi-server untuk JSON dan menggunakan hasilnya untuk mengisi sisi klien <select> elemen . Ini berfungsi untuk enum sederhana dan enum bitflag.

Saya telah memasukkan solusi ujung ke ujung karena saya pikir sebagian besar orang yang ingin membuat serial C # enum ke JSON mungkin juga akan menggunakannya untuk mengisi <select>drop-down.

Ini dia:

Contoh Enum

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

Enum kompleks yang menggunakan OR bitwise untuk menghasilkan sistem izin. Jadi Anda tidak bisa mengandalkan indeks sederhana [0,1,2 ..] untuk nilai integer enum.

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

Kode di atas menggunakan kerangka kerja NancyFX untuk menangani permintaan Dapatkan. Ini menggunakan Response.AsJson()metode pembantu Nancy - tetapi jangan khawatir, Anda dapat menggunakan formatter JSON standar karena enum telah diproyeksikan menjadi jenis anonim sederhana yang siap untuk serialisasi.

JSON yang dihasilkan

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

Sisi Klien - 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 Sebelumnya

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

HTML Setelah

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

Untuk inti ASP.Net Cukup tambahkan berikut ini ke Kelas Startup Anda:

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

Anda dapat membuat JsonSerializerSettings dengan panggilan ke JsonConverter.SerializeObject seperti di bawah ini:

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

Melihat bahwa tidak ada jawaban untuk serialisasi ketika ada atribut Deskripsi.

Ini implementasi saya yang mendukung atribut Deskripsi.

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
}

Pemakaian:

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

Untuk .Net Core: -

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

Di .net core 3 ini sekarang dimungkinkan dengan kelas bawaan di 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);

Untuk mengonfigurasi JsonStringEnumConverterdengan dekorasi atribut untuk properti tertentu:

using System.Text.Json.Serialization;

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

Jika Anda ingin selalu mengonversi enum sebagai string, letakkan atribut di enum itu sendiri.

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

Asp.Net Core 3 dengan System.Text.Json

public void ConfigureServices(IServiceCollection services)
{

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

    //...
 }

Kalau-kalau ada orang yang menemukan hal di atas tidak cukup, saya akhirnya puas dengan kelebihan ini:

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

Ini adalah pertanyaan lama tapi saya pikir saya akan berkontribusi untuk berjaga-jaga. Dalam proyek saya, saya menggunakan model terpisah untuk permintaan Json. Model biasanya memiliki nama yang sama dengan objek domain dengan awalan "Json". Model dipetakan menggunakan AutoMapper . Dengan meminta model json mendeklarasikan properti string yang merupakan enum pada kelas domain, AutoMapper akan memutuskan untuk presentasi stringnya.

Jika Anda bertanya-tanya, saya perlu model terpisah untuk kelas serial Json karena serializer inbuilt muncul dengan referensi melingkar sebaliknya.

Semoga ini bisa membantu seseorang.

Anda benar-benar dapat menggunakan JavaScriptConverter untuk mencapai ini dengan JavaScriptSerializer bawaan. Dengan mengonversi enum Anda menjadi Uri, Anda dapat menyandikannya sebagai string.

Saya telah menjelaskan bagaimana melakukan ini untuk kencan tetapi ini dapat digunakan untuk enum juga. Format JSON DateTime Kustom untuk .NET JavaScriptSerializer .

Tidak yakin apakah ini masih relevan tetapi saya harus menulis langsung ke file json dan saya datang dengan berikut ini beberapa jawaban stackoverflow bersama-sama

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

Ini memastikan semua kunci json saya huruf kecil mulai sesuai dengan "aturan" json. Memformatnya dengan lekukan dan mengabaikan nol dalam output. Sedap dengan menambahkan StringEnumConverter itu mencetak enum dengan nilai string mereka.

Secara pribadi saya menemukan ini paling bersih yang bisa saya buat, tanpa harus mengotori model dengan anotasi.

pemakaian:

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

Saya telah mengumpulkan semua bagian dari solusi ini menggunakan Newtonsoft.Jsonperpustakaan. Ini memperbaiki masalah enum dan juga membuat penanganan kesalahan jauh lebih baik, dan berfungsi di layanan yang di-host IIS. Ini kode yang cukup banyak, sehingga Anda dapat menemukannya di GitHub di sini: https://github.com/jongrant/wcfjsonserializer/blob/master/NewtonsoftJsonFormatter.cs

Anda harus menambahkan beberapa entri ke Web.configagar dapat berfungsi, Anda dapat melihat contoh file di sini: https://github.com/jongrant/wcfjsonserializer/blob/master/Web.config

Dan untuk VB.net saya menemukan karya-karya berikut:

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)

Opsi yang sedikit lebih tahan di masa depan

Menghadapi pertanyaan yang sama, kami memutuskan bahwa kami membutuhkan versi khusus StringEnumConverteruntuk memastikan bahwa nilai enum kami dapat berkembang dari waktu ke waktu tanpa merusak secara serampangan pada sisi deserialisasi (lihat latar belakang di bawah). MenggunakanSafeEnumConverter bawah ini memungkinkan deserialization untuk menyelesaikan bahkan jika payload mengandung nilai untuk enum yang tidak memiliki definisi bernama, lebih dekat dengan bagaimana konversi int-to-enum akan bekerja.

Pemakaian:

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

atau

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

Sumber:

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

Latar Belakang

Ketika kami melihat menggunakan StringEnumConverter, masalah yang kami miliki adalah bahwa kami juga membutuhkan kepasifan untuk kasus ketika nilai enum baru ditambahkan, tetapi tidak setiap klien segera menyadari nilai baru. Dalam kasus ini, StringEnumConverterpaket dengan Newtonsoft JSON melempar JsonSerializationExceptionmirip dengan "Kesalahan mengkonversi nilai SomeString untuk mengetik EnumType" dan kemudian seluruh proses deserialisasi gagal. Ini adalah pemecah kesepakatan bagi kami, karena bahkan jika klien berencana mengabaikan / membuang nilai properti yang tidak dimengerti, ia masih harus mampu melakukan deserialisasi sisa muatan!

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