如何在不反转堆栈的情况下使用 System.Text.Json 将 Stack<T> 序列化为 JSON？

Question

如果我有一个Stack<T>for some T，并使用 newSystem.Text.Json.JsonSerializer将其往返传输到 JSON ，则堆栈中项目的顺序将在反序列化后颠倒。如何使用此序列化程序将堆栈序列化和反序列化为 JSON 而不会发生这种情况？

详情如下。我有一个Stack<int>并推送 3 个值1, 2, 3。然后我使用 将其序列化为 JSON JsonSerializer，结果是

[3,2,1]

但是，当我将 JSON 反序列化为新堆栈时，堆栈中的整数被反转，稍后断言堆栈顺序等于失败：

var stack = new Stack<int>(new [] { 1, 2, 3 });

var json = JsonSerializer.Serialize(stack);

var stack2 = JsonSerializer.Deserialize<Stack<int>>(json);

var json2 = JsonSerializer.Serialize(stack2);

Console.WriteLine("Serialized {0}:", stack);
Console.WriteLine(json); // Prints [3,2,1]

Console.WriteLine("Round-tripped {0}:", stack);
Console.WriteLine(json2); // Prints [1,2,3]

Assert.IsTrue(stack.SequenceEqual(stack2)); // Fails
Assert.IsTrue(json == json2);               // Also fails

如何防止序列化程序在序列化期间反转堆栈？

演示小提琴在这里。

Answer 1

这似乎是序列化程序中的错误。在 .NET Core 3.1 中，有一些代码CreateDerivedEnumerableInstance(ref ReadStack state, JsonPropertyInfo collectionPropertyInfo, IList sourceList)可以从反序列化列表中创建堆栈：

else if (instance is Stack<TDeclaredProperty> instanceOfStack)
{
    foreach (TDeclaredProperty item in sourceList)
    {
        instanceOfStack.Push(item);
    }

    return instanceOfStack;
}

然而，它以错误的顺序推动它们。因此，需要自定义JsonConverter<Stack<T>>才能正确反序列化Stack<T>. 此外，aJsonConverterFactory可用于为每种堆栈类型制造合适的转换器Stack<T>：

public class StackConverterFactory : JsonConverterFactory
{
    public override bool CanConvert(Type typeToConvert)
    {
        return GetStackItemType(typeToConvert) != null;
    }

    public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
    {
        var itemType = GetStackItemType(typeToConvert);
        var converterType = typeof(StackConverter<,>).MakeGenericType(typeToConvert, itemType);
        return (JsonConverter)Activator.CreateInstance(converterType);
    }

    static Type GetStackItemType(Type type)
    {
        while (type != null)
        {
            if (type.IsGenericType)
            {
                var genType = type.GetGenericTypeDefinition();
                if (genType == typeof(Stack<>))
                    return type.GetGenericArguments()[0];
            }
            type = type.BaseType;
        }
        return null;
    }
}

public class StackConverter<TItem> : StackConverter<Stack<TItem>, TItem>
{
}

public class StackConverter<TStack, TItem> : JsonConverter<TStack> where TStack : Stack<TItem>, new()
{
    public override TStack Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        var list = JsonSerializer.Deserialize<List<TItem>>(ref reader, options);
        if (list == null)
            return null;
        var stack = typeToConvert == typeof(Stack<TItem>) ? (TStack)new Stack<TItem>(list.Count) : new TStack();
        for (int i = list.Count - 1; i >= 0; i--)
            stack.Push(list[i]);
        return stack;
    }

    public override void Write(Utf8JsonWriter writer, TStack value, JsonSerializerOptions options)
    {
        writer.WriteStartArray();
        foreach (var item in value)
            JsonSerializer.Serialize(writer, item, options);
        writer.WriteEndArray();
    }
}

然后JsonSerializerOptions按如下方式使用它：

var stack = new Stack<int>(new [] { 1, 2, 3 });

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

var json = JsonSerializer.Serialize(stack, options);

var stack2 = JsonSerializer.Deserialize<Stack<int>>(json, options);

var json2 = JsonSerializer.Serialize(stack2, options);

Assert.IsTrue(stack.SequenceEqual(stack2)); // Passes
Assert.IsTrue(json == json2);  // Passes

转换器也可以直接应用于某些数据模型，使用 JsonConverterAttribute

public class Model
{
    [JsonConverter(typeof(StackConverter<int>))]
    public Stack<int> Stack { get; set; }
}

演示小提琴在这里。

更新：看起来往返Stack<T>不会被内置到JsonSerializer. 请参阅（反）使用 JsonSerializer 序列化堆栈应该往返 #41887（已关闭）：

我们不应该这样做。为了往返，在哪一侧反转项目（序列化或反序列化）没有标准，因此作为重大变更候选者，它是一个非入门者。当前行为与 Newtonsoft.Json 行为兼容。

有一个工作项目提供了一个示例转换器，显示了如何在 JSON 文档中进行往返，我认为这足以解决这个问题：dotnet/docs#16690。这是这个转换器的样子 - dotnet/docs#16225 (comment)。