JSON.NET - custom enum handling at deserialization

Question

We have a JSON that we can deserialize into a custom domain model, no problems at all. It includes a property which is a custom enum:

public enum UserType
{
    President,
    Chump
}

We've now changed our enum class but still need to accept and deserialize the previous values of any JSON's that arrive. It's like we now have two versions of our JSON

public enum UserType
{
    President,
    Vice-President,
    Citizen  // Chump maps to Citizen, now.
}

and in the json itself..

"userType": "chump"; // needs to map to Citizen

I'm not sure how to do this.

Is this using JsonConverter ?

Also, this is our custom settings we use for all our serialization and deserializtion. NOTE: we serialize any enum to it's string description/value, not it's int value.

internal static JsonSerializerSettings JsonSerializerSettings => new JsonSerializerSettings
{
    Converters = new JsonConverter[]
    {
        new StringEnumConverter()
    },
    Formatting = Formatting.Indented
};

Omar Muscatello · Accepted Answer · 2018-02-08 08:20:53Z

In your Enum just add the EnumMember attribute which specify the value for serialization/deserialization process.

public enum UserType
{
    President,
    VicePresident,

    [EnumMember(Value = "chump")]
    Citizen  // Chump maps to Citizen, now.
}

The property userType will be Citizen when, in your json, the userType property is equal to "Chump" or "Citizen".

Remember to add the System.Runtime.Serialization reference to your project.

Edit

I noticed that the check of the Value property of EnumMember attribute is case-sensitive. So you can't use "Chump" if in your json you have "chump". To solve this problem you can use a custom StringEnumConverter.

public class UserTypeEnumConverter : StringEnumConverter
{
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var userTypeType = typeof(UserType);
        if (objectType == userTypeType)
        {
            var value = reader.Value.ToString().ToLower();

            foreach (var item in Enum.GetNames(userTypeType))
            {
                var memberValue = GetEnumMemberValue(userTypeType.GetMember(item)[0]);
                if (memberValue != null && memberValue.ToLower() == value)
                {
                    return Enum.Parse(userTypeType, item);
                }
            }
        }

        return base.ReadJson(reader, objectType, existingValue, serializer);
    }
}

private static string GetEnumMemberValue(MemberInfo memberInfo)
{
    var attributes = memberInfo.GetCustomAttributes(typeof(EnumMemberAttribute), inherit: false);

    if (attributes.Length == 0) return null;

    return ((EnumMemberAttribute)attributes[0]).Value;
}

In the above code, I check only the EnumMember attribute because the UserType's members case-insensitive check is already done by the default StringEnumConvert.

Note that this converter will work only for your UserType enum beacuse of the check:

var userTypeType = typeof(UserType);
if (objectType == userTypeType)
{

Replace the JsonSerializerSettings initialization with:

internal static JsonSerializerSettings JsonSerializerSettings => new JsonSerializerSettings
{
    Converters = new JsonConverter[]
    {
        new UserTypeEnumConverter()
    },
    Formatting = Formatting.Indented
};

I assumed that Vice-President enumerator is VicePresident in UserType.

Ta for the effort - really really helps. Even going so far as to show how to use it in a JsonSerializerSettings class. I'm going to give the answer to @martin though because I found his ReadJson a tiny bit simpler to read and a bit more succinct. But I seriously do appreciated your effort and help. It has helped me, though. (I can't give 2x ticks :( )
If you run into trouble with deserialization of string enums and you suspect it is caused by the case of the value, double check that your type is actually an enum to begin with. I just lost an hour troubleshooting why "GET" would not deserialize into a HttpMethod thinking HttpMethod was a enum.

Pure.Krome · Accepted Answer · 2018-02-08 12:01:28Z

You can implement a custom Converter deriving from StringEnumConverter:

public class UserTypeEnumConverter : StringEnumConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(UserType);
    }

    public override object ReadJson(JsonReader reader, 
                                    Type objectType, 
                                    object existingValue, 
                                    JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.Null)
        {
            var isNullable = (Nullable.GetUnderlyingType(objectType) != null);
            if (!isNullable)
            {
                throw new JsonSerializationException();
            }
            return null;
        }

        var token = JToken.Load(reader);
        var value = token.ToString();
        if (string.Equals(value, "chump", StringComparison.OrdinalIgnoreCase))
        {
            return UserType.Citizen;
        }
        else
        {
            return base.ReadJson(reader, objectType, existingValue, serializer);
        }               
    }
}

The converter handles the case when the underlying type is nullable as well and is invoked only when the type of property declared on the deserialized class is UserType. It then checks if the value being parsed is the "deprecated" one and if not, it delegates the reading to the base StringEnumConverter.

Also, just edited it to make it a bit more readable and moved the isNullable inside the == JsonToken.Null check ... why check if it's nullable or not for all those TokenTypes that are not JsonToken.Null? Waste of unused cpu (yes yes ... micro opt... etc).

Collectives™ on Stack Overflow

JSON.NET - custom enum handling at deserialization

2 Answers 2

Edit

3 Comments

3 Comments

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Edit

3 Comments

3 Comments

Related