Unterstützt JsonStringEnumConverter (System.Text.Json) Nullwerte?

Ich verschiebe meinen Code von .NET Core 2.x auf .NET Core 3.x (dh verwende die native Bibliothek System.Text.Json). Dabei bin ich auf einige Probleme Newtonsoft.Jsongestoßen, bei denen die frühere Unterstützung für nullfähige Aufzählungen derzeit keinen eindeutigen Migrationspfad hat - es sieht so aus, als würde sie in .NET Core 3.x nicht unterstützt.

Bei Verwendung Newtonsoft.Jsondes JSON-Konverters wurden beispielsweise nullfähige Aufzählungen unterstützt, z.

public enum UserStatus
{
    NotConfirmed,
    Active,
    Deleted
}

public class User
{
    public string UserName { get; set; }

    [JsonConverter(typeof(StringEnumConverter))]  // using Newtonsoft.Json
    public UserStatus? Status { get; set; }       // Nullable Enum
}

Die aktuelle Version der nativen Bibliothek System.Text.Jsonscheint dies nicht zu unterstützen.

Wie löse ich dieses Problem? Ich kann meinen Code nicht migrieren!

Leider gibt es derzeit keine "out-of-the-box" System.Text.Json-Unterstützung für die Konvertierung von nullbaren Aufzählungen.

Es gibt jedoch eine Lösung, indem Sie Ihren eigenen benutzerdefinierten Konverter verwenden . (siehe unten) .

Die Lösung. Verwenden Sie einen benutzerdefinierten Konverter.

Sie können es an Ihrem Grundstück anbringen, indem Sie es mit dem benutzerdefinierten Konverter dekorieren:

// using System.Text.Json
[JsonConverter(typeof(StringNullableEnumConverter<UserStatus?>))]  // Note the '?'
public UserStatus? Status { get; set; }                            // Nullable Enum

Hier ist der Konverter:

public class StringNullableEnumConverter<T> : JsonConverter<T>
{
    private readonly JsonConverter<T> _converter;
    private readonly Type _underlyingType;

    public StringNullableEnumConverter() : this(null) { }

    public StringNullableEnumConverter(JsonSerializerOptions options)
    {
        // for performance, use the existing converter if available
        if (options != null)
        {
            _converter = (JsonConverter<T>)options.GetConverter(typeof(T));
        }

        // cache the underlying type
        _underlyingType = Nullable.GetUnderlyingType(typeof(T));
    }

    public override bool CanConvert(Type typeToConvert)
    {
        return typeof(T).IsAssignableFrom(typeToConvert);
    }

    public override T Read(ref Utf8JsonReader reader, 
        Type typeToConvert, JsonSerializerOptions options)
    {
        if (_converter != null)
        {
            return _converter.Read(ref reader, _underlyingType, options);
        }

        string value = reader.GetString();

        if (String.IsNullOrEmpty(value)) return default;

        // for performance, parse with ignoreCase:false first.
        if (!Enum.TryParse(_underlyingType, value, 
            ignoreCase: false, out object result) 
        && !Enum.TryParse(_underlyingType, value, 
            ignoreCase: true, out result))
        {
            throw new JsonException(
                $"Unable to convert \"{value}\" to Enum \"{_underlyingType}\".");
        }

        return (T)result;
    }

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

Hoffe, das hilft, bis es native Unterstützung gibt, ohne dass ein benutzerdefinierter Konverter erforderlich ist!

Sie sollten in der Lage sein, Ihr ursprüngliches Verhalten wiederherzustellen, indem Sie das Newtonsoft JSON-Nuget installieren und dieses in Ihren Code einfügen. Ich nehme an, Sie migrieren eine ASP-App:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers()
        .AddNewtonsoftJson();
}