JavaScriptSerializer-文字列としての列挙型のJSONシリアル化

enumプロパティを含むクラスがあり、を使用してオブジェクトをシリアル化するJavaScriptSerializerと、jsonの結果にはstring「名前」ではなく列挙型の整数値が含まれます。stringカスタムを作成せずに、jsonで列挙型を取得する方法はありJavaScriptConverterますか？おそらく、enum定義またはオブジェクトプロパティを装飾できる属性があるのでしょうか。

例として：

enum Gender { Male, Female }

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

望ましいjson結果：

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

理想的には、組み込みの.NETフレームワーククラスを使用して回答を探すことができますが、それができない場合は（Json.netなど）を歓迎します。

いいえ、使用できる特別な属性はありません。文字列表現ではなく、数値にJavaScriptSerializerシリアル化enumsします。enumを数値ではなく名前としてシリアル化するには、カスタムシリアル化を使用する必要があります。

あなたの代わりにJSON.Netを使用することができる場合JavaScriptSerializerを参照するよりも 、この質問の答えが提供するOmerBakhari：JSON.netは（属性を経由して、このユースケースをカバー[JsonConverter(typeof(StringEnumConverter))]）および他の多くは、.NETシリアライザに建てによって処理されません。これはシリアライザの機能を比較するリンクです。

Json.NETが私が探している正確な機能をStringEnumConverter属性で提供していることがわかりました：

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

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

詳細については、StringEnumConverterドキュメントをご覧ください。

このコンバーターをよりグローバルに構成する他の場所があります。

• enumを常に文字列としてシリアル化/逆シリアル化する場合は、enum自体：

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

• 場合には誰もがあなたのJsonSerializer（によって提案にコンバータを追加することができ、属性の装飾を避けたいビョルンエギル）：

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

  そして、それはそのシリアル化中に見られるすべての列挙型に対して機能します（Travisが推奨）

• またはJsonConverter（推奨） バナナが）：

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

さらに、StringEnumConverter（NamingStrategy、Boolean）コンストラクターを使用することにより、大文字小文字の区別と数値が引き続き受け入れられるかどうかを制御できます。

c＃enumを文字列としてJSONシリアル化するために、以下をglobal.asaxに追加します

  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の回答は、c＃列挙型のJSONシリアル化をASP.NETのみの文字列として設定します（Web APIなど）。

ただし、アドホックシリアル化でも機能するようにするには、開始クラス（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;
});

Json.NETページの詳細

さらに、列挙型メンバーに特定のテキストとの間でシリアル化/逆シリアル化させるには、

System.Runtime.Serialization.EnumMember

このような属性：

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

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

（@ob。の）トップアンサーのようにソースモデルを変更できず、@ Iggyのようにグローバルに登録したくありませんでした。そこで、https：//stackoverflow.com/a/2870420/237091と@Iggyのhttps://stackoverflow.com/a/18152942/237091を組み合わせて、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()
        }
    })

Omer Bokhariとuriの答えの組み合わせは常に私の解決策です。私が提供したい値は通常、特に必要に応じて列挙型を変更できるようにするために、列挙型にある値とは異なるためです。

だから誰かが興味を持っているなら、それはこのようなものです：

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

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

これは、簡単に追加することによって行われているScriptIgnoreに属性をGenderそれがシリアライズされないように引き起こして、プロパティ、および追加GenderString財産ん連載を取得します：

class Person
{
    int Age { get; set; }

    [ScriptIgnore]
    Gender Gender { get; set; }

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

このバージョンのスティーブンの答えは、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; 
        }
    }
}

ここにnewtonsoft.jsonの答えがあります

enum Gender { Male, Female }

class Person
{
    int Age { get; set; }

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

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

属性JsonSerializerを使用したくない場合は、コンバーターを追加することもできJsonConverterます。

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

それenumは、そのシリアル化中に見られるすべてに対して機能します。

サーバー側のC＃列挙型をJSONにシリアル化し、その結果を使用してクライアント側にデータを取り込む単純なソリューションを次に示します <select>要素を設定。これは、単純な列挙型とビットフラグ列挙型の両方で機能します。

エンドツーエンドのソリューションを含めたのは、C＃列挙型をJSONにシリアル化したいほとんどの人は、おそらくそれを使用して<select>ドロップダウンを埋めるだろうからです。

ここに行く：

列挙型の例

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

ビット単位のORを使用してアクセス許可システムを生成する複雑な列挙型。したがって、列挙型の整数値を単純なインデックス[0,1,2 ..]に依存することはできません。

サーバー側-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);
};

上記のコードは、NancyFXフレームワークを使用してGetリクエストを処理します。ナンシーのResponse.AsJson()ヘルパーメソッドを使用します。ただし、列挙型はシリアル化の準備ができた単純な匿名型に既に投影されているため、標準のJSONフォーマッターを使用できます。

生成されたJSON

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

クライアント側-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

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

後のHTML

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

ASP.Netコアの場合以下をスタートアップクラスに追加するだけです。

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

次のようにJsonConverter.SerializeObjectを呼び出してJsonSerializerSettingsを作成できます。

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

Description属性がある場合、シリアル化の応答がないことに注意してください。

これが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");
    }
}

列挙型：

public enum FooEnum
{
    // Will be serialized as "Not Applicable"
    [Description("Not Applicable")]
    NotApplicable,

    // Will be serialized as "Applicable"
    Applicable
}

使用法：

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

.Net Coreの場合：-

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

.net core 3では、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);

JsonStringEnumConverter特定のプロパティに属性装飾を設定するには：

using System.Text.Json.Serialization;

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

常に列挙型を文字列として変換する場合は、属性を列挙型自体に配置します。

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

Asp.Net Core 3とSystem.Text.Json

public void ConfigureServices(IServiceCollection services)
{

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

    //...
 }

誰かが上記で不十分だと思った場合に備えて、私はこの過負荷で落ち着きました：

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

これは古い質問ですが、念のために貢献したいと思いました。私のプロジェクトでは、Jsonリクエストに対して個別のモデルを使用しています。モデルは通常、「Json」プレフィックスを持つドメインオブジェクトと同じ名前になります。モデルはAutoMapperを使用してマップされます。jsonモデルにドメインクラスの列挙型である文字列プロパティを宣言させることにより、AutoMapperはその文字列表現に解決します。

ご参考までに、組み込みのシリアライザーが循環参照を別の方法で作成するため、Jsonシリアル化クラスの個別のモデルが必要です。

これが誰かを助けることを願っています。

実際には、JavaScriptConverterを使用して、組み込みのJavaScriptSerializerでこれを実現できます。列挙型をUriに変換することで、それを文字列としてエンコードできます。

日付に対してこれを行う方法を説明しましたが、列挙型にも使用できます。 .NET JavaScriptSerializerのカスタムDateTime JSON形式。

これがまだ関連しているかどうかはわかりませんが、jsonファイルに直接書き込む必要があり、いくつかのスタックオーバーフローの回答をまとめて次のように考えました

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

jsonの「ルール」に従って、すべてのjsonキーが小文字であることを保証します。インデントをきれいにフォーマットし、出力のnullを無視します。また、StringEnumConverterを追加することで、列挙型とその文字列値を出力します。

個人的には、注釈でモデルを汚すことなく、これが私が思いつく最もクリーンなものだと思います。

使用法：

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

Newtonsoft.Jsonライブラリを使用して、このソリューションのすべての要素をまとめました。列挙型の問題を修正し、エラー処理を大幅に改善し、IISがホストするサービスで機能します。それはかなりたくさんのコードなので、GitHubで見つけることができます： https://github.com/jongrant/wcfjsonserializer/blob/master/NewtonsoftJsonFormatter.csで。

これを機能させるには、エントリをいくつか追加するWeb.config必要があります。https：//github.com/jongrant/wcfjsonserializer/blob/master/Web.configのサンプルファイルを ご覧ください。

そしてVB.netの場合、私は次の作品を見つけました。

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)

もう少し将来性のあるオプション

同じ質問に直面StringEnumConverterして、列挙型の値が逆シリアル化の側で壊滅的に壊れることなく、時間の経過とともに拡張できることを確認するためのカスタムバージョンが必要であると判断しました（以下の背景を参照）。を使用してSafeEnumConverter以下、ペイロードに名前付き定義のない列挙型の値が含まれている場合でも、int-to-enum変換がどのように機能するかに近い逆シリアル化を終了できます。

使用法：

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

または

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

ソース：

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

バックグラウンド

を使用して調べたときStringEnumConverterの問題は、新しい列挙値が追加された場合に受動性も必要でしたが、すべてのクライアントが新しい値をすぐに認識しているわけではないことです。これらの場合、StringEnumConverterNewtonsoft JSONでパッケージ化されたJsonSerializationExceptionものは、「SomeStringの値をEnumType型に変換するエラー」のようなものをスローし、逆シリアル化プロセス全体が失敗します。これは、クライアントが理解できないプロパティ値を無視/破棄することを計画していたとしても、残りのペイロードを逆シリアル化できる必要があるため、私たちにとって取引ブレーカーでした。

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