How can I ignore unknown enum values during json deserialization?

Looking through the handful of suggestions that exist for this problem, all of them use StringEnumConverter as a backbone, but no suggestions use it through inheritance. If your scenario was like mine, I was taking a 3rd party API response, which has ton of possible enum values, that may change over time. I only care about maybe 10 of those values, so all the other values I want to fallback on a default value(like Unknown). Here's my enum converter to do this:

/// <inheritdoc /> /// <summary> /// Defaults enum values to the base value if /// </summary> public class DefaultUnknownEnumConverter : StringEnumConverter { /// <summary> /// The default value used to fallback on when a enum is not convertable. /// </summary> private readonly int defaultValue; /// <inheritdoc /> /// <summary> /// Default constructor. Defaults the default value to 0. /// </summary> public DefaultUnknownEnumConverter() {} /// <inheritdoc /> /// <summary> /// Sets the default value for the enum value. /// </summary> /// <param name="defaultValue">The default value to use.</param> public DefaultUnknownEnumConverter(int defaultValue) { this.defaultValue = defaultValue; } /// <inheritdoc /> /// <summary> /// Reads the provided JSON and attempts to convert using StringEnumConverter. If that fails set the value to the default value. /// </summary> /// <param name="reader">Reads the JSON value.</param> /// <param name="objectType">Current type that is being converted.</param> /// <param name="existingValue">The existing value being read.</param> /// <param name="serializer">Instance of the JSON Serializer.</param> /// <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}"); } } /// <inheritdoc /> /// <summary> /// Validates that this converter can handle the type that is being provided. /// </summary> /// <param name="objectType">The type of the object being converted.</param> /// <returns>True if the base class says so, and if the value is an enum and has a default value to fall on.</returns> public override bool CanConvert(Type objectType) { return base.CanConvert(objectType) && objectType.GetTypeInfo().IsEnum && Enum.IsDefined(objectType, defaultValue); } } 

Usage is the same as other examples:

[JsonConverter(typeof(DefaultUnknownEnumConverter))] public enum Colors { Unknown, Red, Blue, Green, } [JsonConverter(typeof(DefaultUnknownEnumConverter), (int) NotFound)] public enum Colors { Red = 0, Blue, Green, NotFound } 

If you only care about deserialization, another simple thing you could do is to define the enum field as string and add another 'get' only field that parses the string field to either one of the known values or to 'unknown'. This field should be 'JsonIgnore'd.

You could use a custom StringEnumConverter, like this:

public class SafeStringEnumConverter : StringEnumConverter { public object DefaultValue { get; } public SafeStringEnumConverter(object defaultValue) { DefaultValue = defaultValue; } public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { try { return base.ReadJson(reader, objectType, existingValue, serializer); } catch { return DefaultValue; } } } 

Then you can use it as follows:

[JsonConverter(typeof(SafeStringEnumConverter), Unknown)] public enum Colors { Unknown, [EnumMember(Value = "MY_VALUE_1")] MyValue, [EnumMember(Value = "MY_VALUE_2")] MyValue2 } 

Here's some sample code for Vignesh Chandramohan answer. Certainly the simplest solution if you're just deserialising.

public class SampleClass { [JsonProperty("sampleEnum")] public string sampleEnumString; [JsonIgnore] public SampleEnum sampleEnum { get { if (Enum.TryParse<SampleEnum>(sampleEnumString, true, out var result)) { return result; } return SampleEnum.UNKNOWN; } } } public enum SampleEnum { UNKNOWN, V1, V2, V3 } 

Improving on @BrianRogers I have wrote the following code and it passes all of his tests + it deals with the EnumAttribute questions! (I had the same problem of Nullables Enums recently)

class TolerantEnumConverter : StringEnumConverter { public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { try { return base.ReadJson(reader, objectType, existingValue, serializer); } catch { if (IsNullableType(objectType)) return null; //I would throw the exception, but to pass the tests return Enum.Parse(objectType, Enum.GetNames(objectType).First()); } } private static bool IsNullableType(Type t) { if (t == null) throw new ArgumentNullException(nameof(t)); return (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>)); } } 

If someone is looking for a similar solution for System.Text.Json, I wrote a generic converter that can be used for a specific enum type:

public class FallbackJsonEnumConverter<TEnum> : JsonConverter<TEnum> where TEnum : struct, Enum { public override TEnum Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => Enum.TryParse(reader.GetString(), true, out TEnum result) ? result : default; public override void Write(Utf8JsonWriter writer, TEnum value, JsonSerializerOptions options) => writer.WriteStringValue(value.ToString()); } 

Just decorade the property in your model and you will get the default value of the enum instead an exception if you try to deserialize an unknown value:

public record MyDto { [JsonConverter(typeof(FallbackJsonEnumConverter<MyEnum>))] public MyEnum EnumValue { get; init; } } 

Why not keep it simple?

There is no use for a nullable enum, since this can be simplified just by adding a default option, e.g. "Unknown".

And secondly, if you don't need the support for numerical values, the code can be simplified like this:

public class JsonEnumConverter : JsonConverter<object> { public override bool CanConvert(Type typeToConvert) => typeToConvert.IsEnum; public override object? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { // try to convert Json string if (reader.TokenType == JsonTokenType.String) if (Enum.TryParse(typeToConvert, reader.GetString(), out var result)) return result; // else return the default enum value return Activator.CreateInstance(typeToConvert); } public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options) { writer.WriteStringValue(value.ToString()); } } 

Usage:

var data = JsonSerializer.Deserialize<TResult>(jsonString, new JsonSerializerOptions { Converters = { new JsonEnumConverter() } }); 

Just make sure your enum has a default option.

 public enum MyEnum { Unknown = 0, // this will be the default OneValidOption, AnotherOption }