在使用System.Text.Json进行序列化时抛出StackOverflowException异常

Question

我无法确定以下代码为何在Write期间抛出StackOverflowException异常。我的目标是利用类型鉴别器帮助我在序列化/反序列化对象时保留具体实现细节。如何解决这个问题？

using System.Text.Json;
using System.Text.Json.Serialization;

public abstract class ClassC
{
    public string PropertyC { get; set; }
    public string TypeDiscriminator => this.GetType().FullName;
}

public class ClassB : ClassC
{
    public string PropertyB { get; set; }
}

public class ClassA : ClassB
{
    public string PropertyA { get; set; }
}

public class PolymorphicJsonConverter : JsonConverter where TBase : ClassC
{
    public override bool CanConvert(Type typeToConvert) => typeof(TBase).IsAssignableFrom(typeToConvert);

    public override TBase Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        using (var jsonDoc = JsonDocument.ParseValue(ref reader))
        {
            var root = jsonDoc.RootElement;
            var typeDiscriminator = root.GetProperty("TypeDiscriminator").GetString();

            var type = Type.GetType(typeDiscriminator);
            if (type == null)
            {
                throw new JsonException($"Type {typeDiscriminator} could not be found.");
            }

            return (TBase)JsonSerializer.Deserialize(root.GetRawText(), type, options);
        }
    }

    public override void Write(Utf8JsonWriter writer, TBase value, JsonSerializerOptions options)
    {
        // 修改这里以避免递归调用
        JsonSerializer.Serialize(writer, value, value.GetType(), options);
    }
}

public class Program
{
    public static void Main()
    {
        var options = new JsonSerializerOptions
        {
            Converters = { new PolymorphicJsonConverter() },
            WriteIndented = true
        };

        ClassA classA = new ClassA { PropertyA = "ValueA", PropertyB = "ValueB", PropertyC = "ValueC" };

        string json = JsonSerializer.Serialize(classA, options);
        ClassC deserialized = JsonSerializer.Deserialize(json, options);

        Console.WriteLine(json);
        Console.WriteLine(deserialized is ClassA); // 应该输出 'True'
    }
}

Michael Gundlach · Answer

在您的 Write 方法中，您正在递归地再次调用 Write 方法——您创建了一个循环——一段时间后，您的应用程序将耗尽内存。请在 Write 方法中设置断点以查看问题。

应该在 Write 方法中使用一个 writer 对象。以下是一个从官方文档中摘录的基础转换器示例：

using System.Globalization;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace SystemTextJsonSamples
{
    public class DateTimeOffsetJsonConverter : JsonConverter
    {
        public override DateTimeOffset Read(
            ref Utf8JsonReader reader,
            Type typeToConvert,
            JsonSerializerOptions options)
        {
            return DateTimeOffset.ParseExact(reader.GetString()!,
                "MM/dd/yyyy", CultureInfo.InvariantCulture);
        }

        public override void Write(
            Utf8JsonWriter writer,
            DateTimeOffset dateTimeValue,
            JsonSerializerOptions options)
        {
            writer.WriteStringValue(dateTimeValue.ToString(
                "MM/dd/yyyy", CultureInfo.InvariantCulture));
        }
    }
}

Wayne Conrad · Answer

您的问题在于，转换器在此处递归调用了自身：

return (TBase)JsonSerializer.Deserialize(root.GetRawText(), type, options);

递归发生的原因是，在 CanConvert(Type typeToConvert) 方法中，即使 ClassC 的具体派生类型无需转换，也会返回 true。

由于您的基类是抽象的，您可以将转换器修改为在 CanConvert 方法内部添加一个检查，确保传入的类型是抽象的：

public class ClassCJsonConverter : JsonConverter
{
    public override bool CanConvert(Type typeToConvert) => typeToConvert.IsAssignableFrom(typeof(ClassC)) && typeToConvert.IsAbstract;

    public override ClassC? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        using (var jsonDoc = JsonDocument.ParseValue(ref reader))
        {
            var root = jsonDoc.RootElement;
            var typeDiscriminator = root.GetProperty("TypeDiscriminator").GetString();

            var type = typeDiscriminator == null ? null : Type.GetType(typeDiscriminator);
            if (type == null || !CanConvert(type)) // 在这里我们保证不会无限递归。
                throw new JsonException($"无法找到或无效类型: {typeDiscriminator}");

            return (ClassC?)root.Deserialize(type, options);
        }
    }

    public override void Write(Utf8JsonWriter writer, ClassC value, JsonSerializerOptions options) =>
        JsonSerializer.Serialize(writer, value, value.GetType(), options);
}

这个版本假设任何可分配给 ClassC 的类型要么是抽象的（需要进行类型解析），要么是具体的（不需要类型解析）。如果存在非抽象基类型，则此策略将不起作用，您需要采用一种更复杂的方法，如在递归调用期间禁用转换器，就像在 How to use default serialization in a custom System.Text.Json JsonConverter? 中所示那样。

示例代码 #1 可在此处查看。

另外，从 .NET 7 开始，System.Text.Json 内置了对多态类型区分符的支持，因此不再需要自定义转换器。请参阅关于 Is polymorphic deserialization possible in System.Text.Json? 的这个答案。使用这种内置方法，只需向您的类应用以下属性即可实现序列化和反序列化：

[JsonDerivedType(typeof(ClassB), nameof(ClassB))]
[JsonDerivedType(typeof(ClassA), nameof(ClassA))]
[JsonPolymorphic(TypeDiscriminatorPropertyName = "TypeDiscriminator")]
public abstract class ClassC
{
    public string PropertyC { get; set; }
}

[JsonDerivedType(typeof(ClassB), nameof(ClassB))]
[JsonPolymorphic(TypeDiscriminatorPropertyName = "TypeDiscriminator")]
public class ClassB : ClassC
{
    public string PropertyB { get; set; }
}

[JsonDerivedType(typeof(ClassA), nameof(ClassA))]
[JsonPolymorphic(TypeDiscriminatorPropertyName = "TypeDiscriminator")]
public class ClassA : ClassB
{
    public string PropertyA { get; set; }
}

可能需要根据 C# 命名空间调整传递给 [JsonDerivedType(Type derivedType, string typeDiscriminator)] 属性构造函数中的类型区分符值，因为 nameof(type) 并不包含 C# 命名空间。

示例代码 #2 可在此处查看。