JavaScriptSerializer JSON - Serialisierung von enum als string

Nein, es ist kein besonderes Attribut, das Sie verwenden können. JavaScriptSerializer serialisiert enums zu Ihren numerischen Werten und nicht Ihre string-Darstellung. Sie müssten, um das verwenden einer benutzerdefinierten Serialisierung zur Serialisierung des enum als seinen Namen statt numerischer Wert.

Edit:
Wie bereits von @OmerBakhari JSON.net deckt dieser use-case (über das Attribut [JsonConverter(typeof(StringEnumConverter))]) und viele andere, die nicht behandelt werden, durch die eingebaute .net serialisierungsprogramme. Hier ist ein link, über den Vergleich von Funktionen und Funktionalitäten der serialisierungsprogramme.

Fügen Sie die unten, um Ihre globalen.asax für die JSON-Serialisierung in c# enum als 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());

War ich nicht in der Lage, ändern Sie die Quell-Modell wie in der oberen Antwort (von @ob.), und ich wollte nicht, um es zu registrieren, Global wie @Iggy. So kombinierte ich https://stackoverflow.com/a/2870420/237091 und @Iggy ist https://stackoverflow.com/a/18152942/237091 zu ermöglichen, die Einrichtung der string-enum Konverter während der SerializeObject Befehl selbst:

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

Dies geschieht einfach durch das hinzufügen einer ScriptIgnore Attribut der Gender Eigenschaft, wodurch es zu nicht serialisierte, und das hinzufügen einer GenderString Eigenschaft, die hat bekommen serialisierte:

class Person
{
    int Age { get; set; }

    [ScriptIgnore]
    Gender Gender { get; set; }

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

Hier ist die Antwort für newtonsoft.json

enum Gender { Male, Female }

class Person
{
    int Age { get; set; }

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

Hier ist eine einfache Lösung, die serialisiert eine server-side C# - enum zu JSON und benutzt das Ergebnis, um füllen Sie eine client-Seite <select> element. Dies funktioniert sowohl für einfache Enumerationen und bitflag enums.

Ich habe die end-to-end-Lösung, weil ich denke, die meisten Menschen wollen zu serialisieren eines C# - enum zu JSON wird auch wahrscheinlich, es zu füllen, eine <select> drop-down.

Hier geht:

Beispiel Enum

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

Einer komplexen enum verwendet bitweise ORs zu generieren, ein Berechtigungen-system. Sie können also nicht darauf verlassen, dass der einfache index [0,1,2..] für den ganzzahligen Wert des enum.

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

Der obige code verwendet die NancyFX Rahmenwerk zum Umgang mit der Get-Anfrage. Es nutzt Nancy die Response.AsJson() Helfer-Methode - aber keine Sorge, Sie können jede standard-JSON-formatter als die enum bereits projiziert, die in einem einfachen anonymen Typ bereit für die Serialisierung.

Generierten JSON -

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

Client-Seite - 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 Vor

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

HTML Nach

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

Können Sie erstellen JsonSerializerSettings mit dem Aufruf JsonConverter.SerializeObject wie folgt:

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

Für .Net Core :-

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

Dies ist eine alte Frage, aber ich dachte, ich würde tragen, nur für den Fall. In meinen Projekten verwende ich separate Modelle für jede Json-Anfragen. Ein Modell würde in der Regel haben den gleichen Namen als domain-Objekt mit "Json" - Präfix. Modelle sind abgebildet mit AutoMapper. Durch die json-Modell deklarieren Sie eine string-Eigenschaft, die eine enum über domain-Klasse, AutoMapper wird aufgelöst es ist die string-Darstellung.

Falls Sie sich Fragen, brauche ich separate Modelle für die Json-serialisierte Klassen, da eingebaute serializer kommt mit Zirkelbezügen sonst.

Hoffe, das jemand hilft.

Können Sie tatsächlich nutzen eine JavaScriptConverter um dies zu erreichen, die mit der integrierten JavaScriptSerializer. Durch die Umwandlung von enum zu einer Uri Kodieren Sie Sie als string.

Habe ich beschrieben, wie dies für Termine, aber es kann verwendet werden, für die enums als gut.
Benutzerdefinierte DateTime JSON-Format, für .NET JavaScriptSerializer.

Ich haben zusammen alle Stücke von dieser Lösung mit den Newtonsoft.Json Bibliothek. Es behebt das enum-Problem und macht auch die Fehler-handling viel besser, und es funktioniert in IIS gehostete services. Es ist ziemlich viel code, so können Sie es finden auf GitHub hier: https://github.com/jongrant/wcfjsonserializer/blob/master/NewtonsoftJsonFormatter.cs

Müssen Sie einige Einträge, um Ihre Web.config um es zu arbeiten, können Sie eine Beispiel-Datei hier:
https://github.com/jongrant/wcfjsonserializer/blob/master/Web.config

Eine etwas zukunftssichere option

Vor der gleichen Frage, haben wir festgestellt, dass wir brauchten also eine eigene version von StringEnumConverter um sicherzustellen, dass unsere enum-Werte erweitern konnte im Laufe der Zeit, ohne zu brechen katastrophal auf die Deserialisieren Seite (siehe hintergrund unten). Mit der SafeEnumConverter unten ermöglicht die Deserialisierung zu beenden, auch wenn die payload enthält einen Wert für das enum, das nicht über eine benannte definition, näher an, wie int-zu-enum-Umwandlung funktionieren würde.

Verwendung:

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

oder

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

Quelle:

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

Hintergrund

Wenn wir uns auf die Verwendung der StringEnumConverter, das problem hatten wir ist, dass wir auch gebraucht, Passivität für die Fälle, wenn ein neuer enum-Wert Hinzugefügt wurde, aber nicht jeder Kunde war sofort bewusst den neuen Wert. In diesen Fällen, die StringEnumConverter verpackt mit Newtonsoft JSON wirft einen JsonSerializationException ähnlich wie "Fehler beim konvertieren Wert Classextender Typ EnumType" und dann die ganze Deserialisierung schlägt fehl. Das war ein deal breaker für uns, denn auch wenn der client geplant ignorieren/verwerfen Sie den Wert der Eigenschaft, die es nicht verstehen, es immer noch notwendig, um in der Lage sein, zu Deserialisieren der rest der Nutzlast!