Question 210145 in Json Question posted in
Our archive of expertly curated questions and answers provides insights and solutions to common problems related to this popular data interchange format. From parsing and manipulating JSON data to integrating it with various programming languages and web services, our archive has got you covered. Start exploring today and take your JSON skills to the next level

System.Text.Json JsonStringEnumConverter with custom fallback in case of deserialization failures

I have a .NET 6 program that needs to deserialize a JSON string value (returned by external API) into a .NET enum.

The issue is that there are over 100 possible enum values (and more could be added without my knowledge), but I’m only interested in a few of them. So I would like to define an enum type like this and deserialize all the values that I’m not interested in to MyEnum.Unknown:

public enum MyEnum
{
    Unknown = 0,
    Value1,
    Value2,
    Value3,
    // only values that I'm interested in will be defined
}

If I’m using Newtonsoft.Json, I can do this quite easily with a custom JSON converter:

public class DefaultFallbackStringEnumConverter : StringEnumConverter
{
    private readonly object _defaultValue;

    public DefaultFallbackStringEnumConverter() : this(0)
    {
    }

    public DefaultFallbackStringEnumConverter(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 (JsonException)
        {
            return _defaultValue;
        }
    }
}

But with System.Text.Json, I can’t figure out how this can be done easily, because the JsonStringEnumConverter in STJ is actually a JsonConverterFactory that doesn’t do the serialization itself (it throws exceptions in all overrides of JsonConverter as you can see here). Instead the factory creates EnumConverter<T>s that actually do the work, but EnumConverter<T> is internal so I can’t even reference or inherit from it in user code.

Any idea how this can be done easily with STJ or is it not possible at all? Thanks a lot for the help!

Tags:

2

Answers


  1. 0

    You can create a custom JsonConverter

    public class MyEnumJsonConverter : JsonConverter<MyEnum>
{
    public override MyEnum Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
       return Enum.TryParse<MyEnum>(reader.GetString(),true, out var val) ? val : default;
    }

    public override void Write(Utf8JsonWriter writer, MyEnum value, JsonSerializerOptions options)
    {
       writer.WriteStringValue(value.ToString());
    }
}

    Then add an attribute on the property you want the converter to kick in

    public class Test
{
    [JsonConverter(typeof(MyEnumJsonConverter))]
    public MyEnum MyEnum { get; set; }
}
    Login or Signup to reply.
  2. 0

    You could use the decorator pattern and wrap the JsonStringEnumConverter factory in a decorator whose CreateConverter() method wraps the returned EnumConverter<T> in some inner decorator that catches the exception and returns a default value.

    The following does that:

    public class DefaultFallbackStringEnumConverter : JsonConverterFactoryDecorator
{
    public DefaultFallbackStringEnumConverter(JsonStringEnumConverter inner) : base(inner) { }
    public DefaultFallbackStringEnumConverter() : this(new JsonStringEnumConverter()) { }

    protected virtual T GetDefaultValue<T>() where T : struct, Enum => default(T);

    public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
    {
        var inner = base.CreateConverter(typeToConvert, options);
        return (JsonConverter?)Activator.CreateInstance(typeof(EnumConverterDecorator<>).MakeGenericType(Nullable.GetUnderlyingType(typeToConvert) ?? typeToConvert), new object? [] { this, inner });
    }

    sealed class EnumConverterDecorator<T> : JsonConverter<T> where T : struct, Enum
    {
        readonly DefaultFallbackStringEnumConverter parent;
        readonly JsonConverter<T> inner;
        public EnumConverterDecorator(DefaultFallbackStringEnumConverter parent, JsonConverter inner) => 
            (this.parent, this.inner)= (parent ?? throw new ArgumentException(nameof(parent)), (inner as JsonConverter<T>) ?? throw new ArgumentException(nameof(inner)));

        public override bool CanConvert(Type typeToConvert) => inner.CanConvert(typeToConvert);
        
        public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            try
            {
                return inner.Read(ref reader, typeToConvert, options);
            }
            catch (JsonException)
            {
                return parent.GetDefaultValue<T>();
            }
        }
        public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options) => inner.Write(writer, value, options);
    }
}

public class JsonConverterFactoryDecorator : JsonConverterFactory
{
    readonly JsonConverterFactory inner;
    public JsonConverterFactoryDecorator(JsonConverterFactory inner) => this.inner = inner ?? throw new ArgumentNullException(nameof(inner));
    public override bool CanConvert(Type typeToConvert) => inner.CanConvert(typeToConvert);
    public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options) => inner.CreateConverter(typeToConvert, options);
}

    Do note that, unlike Json.NET, System.Text.Json does not have an equivalent to Json.NET’s ConverterParameters (see issue #54187 for confirmation) so if you need a different default value for a specific enum, you will need to subclass DefaultFallbackStringEnumConverter for that specific enum, e.g. like so:

    public enum MyEnum2
{
    Unknown1 = 1,  // Use this value for unknown values
    Value2 = 2,
    Value3 = 3,
}

public class MyEnum2Converter : DefaultFallbackStringEnumConverter
{
    protected override T GetDefaultValue<T>() => typeof(T) == typeof(MyEnum2) ? (T)(object)MyEnum2.Unknown1 : base.GetDefaultValue<T>();
    public override bool CanConvert(Type typeToConvert) => base.CanConvert(typeToConvert) && typeToConvert == typeof(MyEnum2);
}

    Then if your model looks like e.g.:

    public record Model(MyEnum MyEnum, 
                    [property: JsonConverter(typeof(MyEnum2Converter))] MyEnum2? MyEnum2);

    And your JSON looks like:

    {"MyEnum" : "missing value", "MyEnum2" : "missing value" }

    You will be able to deserialize and re-serialize as follows:

    var options = new JsonSerializerOptions
{
    Converters = { new DefaultFallbackStringEnumConverter() },
};

var model = JsonSerializer.Deserialize<Model>(json, options);

var newJson = JsonSerializer.Serialize(model, options);

    Demo fiddle here.

    Login or Signup to reply.
Please signup or login to give your own answer.

Back To Top
Search