JsonConverter fails with nullable enums.

[foggerty]

Description

We need a JsonConverter to use with all Enums in our solution(s), some of which are nullable.

I can get it to work, except with nullable enums as shown below.

Reproduction Steps

public class JsonEnumTypeConverter : JsonConverter<Enum>
{
    public override bool HandleNull => true;

    public override bool CanConvert(Type typeToConvert)
    {
        return typeToConvert.IsEnum ||
            (IsNullableType(typeToConvert) && Nullable.GetUnderlyingType(typeToConvert)!.IsEnum);
    }

    public override Enum? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
		// Custom reading stuff that has to be done to ALL enums.
    }

    public override void Write(Utf8JsonWriter writer, Enum? value, JsonSerializerOptions options)
    {
        writer.WriteStringValue(value is null ? "null" : value.ToString());
    }

    private static bool IsNullableType(Type t)
    {
        return t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>);
    }
}

public enum AnEnum
{
	One,
	Two,
	Three
}

public class ThisWorks
{
	public AnEnum TheEnum { get; set; }
}

public class ThisFails
{
	public AnEnum? TheEnum { get; set; }
}

///////////////////////////////////

var options = new JsonSerializerOptions()
options.Converters.Add(new JsonEnumTypeConverter));

var json = @" ""theEnum"": ""One"" ";

 // this works
var deserialized1 = JsonSerializer.Deserialize<ThisWorks>(json, options); 

// The converter 'JsonEnumTypeConverter' is not compatible with the type 'System.Nullable`1[AnEnum]'
var deserialized2 = JsonSerializer.Deserialize<ThisFails>(json, options); 

Expected behavior

It should handle both non-nullable and nullable enums.

Actual behavior

Fails on nullable enums.

Regression?

No response

Known Workarounds

No response

Configuration

.NET version = 8.
OS = Windows 10.
Arch = x64.

Other information

No response

[dotnet-policy-service[bot]]

Tagging subscribers to this area: @dotnet/area-system-text-json, @gregsdennis
See info in area-owners.md if you want to be subscribed.

[huoyaoyuan]

A JsonConverter should operate on one concrete type. To support a group of types, you need to inherit JsonConverterFactory, like what JsonStringEnumConverter does.

JsonStringEnumConverter is already doing the right thing for you. Note that the "correct" serialization of null is WriteNullValue (null), not WriteStringValue("null") ("null").

If you need more customization, it's suggested to start from the source code of JsonStringEnumConverter.

[foggerty]

So if I'm reading the code right (debatable), I will need a JsonConverterFactory descendant that creates a different JsonConverter descendant depending on if the type it's being asked to parse is nullable or not. Correct? I'll avoid JsonConveter<> is it looks like I'll have to start playing with dynamic creation and that's something that I'd rather avoid right now.

The reason for all of this, BTW, is because all of our domain Enums have -1 (Unknown) and 0 (NotSet) default values, and the JSON reader need to default to -1 if it doesn't recognise it (which I've argued against, but that's another story). Some of them are nullable....

[gregsdennis]

Nullability for enums and other structs is handled automatically via the serializer, but it doesn't like having a single, untyped converter for all enums.

1. Write your converter to be generic where the generic parameter must be an enum:

   public class JsonEnumTypeConverter<T> : JsonConverter<T> where T : Enum
   {
       // remove CanConvert() override
   }

2. Include instances of your converter for each enum type you want to convert. This can be done as a list or with reflection.

   options.Converters.Add(new JsonEnumTypeConverter<AnEnum>());
   options.Converters.Add(new JsonEnumTypeConverter<AnotherEnum>());
   
   // or
   
   var converters = typeof(AnEnum).Assembly
       .DefinedTypes
       .Where(t => t.IsEnum)
       .Select(t => (JsonConverter) Activator.CreateInstance(typeof(JsonConverter).MakeGenericType(t)));
   foreach(var converter in converters)
   {
       options.Converters.Add(converter);
   }

[foggerty]

Ahhhhhh that explains a lot, thanks!