这似乎是序列化程序中的错误。在 .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(评论)。