System.Text.Json：如何将 JsonConverter 应用于具有集合项目的自定义转换器的集合？答案

【问题标题】：System.Text.Json: How to apply a JsonConverter for a collection with a custom converter for the collection's items?System.Text.Json：如何将 JsonConverter 应用于具有集合项目的自定义转换器的集合？
【发布时间】：2020-08-14 19:58:52
【问题描述】：

我有一个要序列化为 json 的类。该类包含一些琐碎的序列化成员，但问题是我有一个来自 cpp 库的对象列表（我有一个 C# 具有该库的包装器）。我可以通过自定义转换器序列化和反序列化库对象，但我有一个它们的列表，我不知道在这种情况下该怎么做。
为简单起见，我将使用以下示例：

class Data
{
    // Some trivial members
    public List<LibraryObject> lst { get; private set; }
}

class LibraryObjectConverter : JsonConverter<LibraryObject>
{
    public override LibraryObject Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        // Implementation logic...
    }

    public override void Write(Utf8JsonWriter writer, LibraryObject value, JsonSerializerOptions options)
    {
        // Implementation logic...
    }
}

如果我的类包含已知数量的这些对象，我可以添加 JsonConverter 标记并为我的类使用默认的 JsonSerivalizer：

class Data
{
    // Some trivial members
    [JsonConverter(typeof(LibraryObjectConverter ))]
    public List<LibraryObject> lst { get; private set; }
}

虽然因为该类包含对象列表，但我不能这样做。
我也知道我可以使用以下代码，它会工作：

var d = new Data();
var serializeOptions = new JsonSerializerOptions();
serializeOptions.Converters.Add(new LibraryObjectkConverter());
serializeOptions.WriteIndented = true;
Console.WriteLine(JsonSerializer.Serialize(d, serializeOptions));

我想要一个不需要 JsonSerializerOptions 的解决方案，所以我可以使用“默认转换器”。
我更喜欢添加标签\逻辑，而不是使用上述解决方案，以方便代码消费者使用。

【问题讨论】：

忘了说，主要问题是反序列化数据类。序列化很容易：我可以创建一个ListLibraryObjectConverter 类，然后为列表中的每个项目编写它并将适当的 JsonTag 添加到属性的声明中。阅读很困难，因为项目的数量是任意的，我想尽可能地遵守 json 约定。

标签： c# json collections system.text.json

【解决方案1】：

你要找的是相当于Newtonsoft的JsonPropertyAttribute.ItemConverterType：

获取或设置序列化属性集合项时使用的 JsonConverter 类型。

不幸的是，从 .NET 5 开始，System.Text.Json 没有直接等效的属性。相反，有必要引入一个JsonConverterdecorator，它使用指定的封装转换器对集合和数组进行序列化和反序列化，以对项目进行序列化和反序列化。

以下JsonConverterFactory 正是这样做的：

public class ItemConverterDecorator<TItemConverter> : JsonConverterFactory where TItemConverter : JsonConverter, new()
{
    readonly TItemConverter itemConverter = new TItemConverter();

    public override bool CanConvert(Type typeToConvert)
    {
        var (itemType, _, _) = GetItemType(typeToConvert);
        if (itemType == null)
            return false;
        return itemConverter.CanConvert(itemType);
    }

    public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
    {
        var (itemType, isArray, isSet) = GetItemType(typeToConvert);
        if (itemType == null)
            return null;
        if (isArray)
            return (JsonConverter)Activator.CreateInstance(typeof(ArrayItemConverterDecorator<>).MakeGenericType(typeof(TItemConverter), itemType), new object [] { options, itemConverter });
        if (!typeToConvert.IsAbstract && !typeToConvert.IsInterface && typeToConvert.GetConstructor(Type.EmptyTypes) != null)
            return (JsonConverter)Activator.CreateInstance(typeof(ConcreteCollectionItemConverterDecorator<,,>).MakeGenericType(typeof(TItemConverter), typeToConvert, typeToConvert, itemType), new object [] { options, itemConverter });
        if (isSet)
        {
            var setType = typeof(HashSet<>).MakeGenericType(itemType);
            if (typeToConvert.IsAssignableFrom(setType))
                return (JsonConverter)Activator.CreateInstance(typeof(ConcreteCollectionItemConverterDecorator<,,>).MakeGenericType(typeof(TItemConverter), setType, typeToConvert, itemType), new object [] { options, itemConverter });
        }
        else
        {
            var listType = typeof(List<>).MakeGenericType(itemType);
            if (typeToConvert.IsAssignableFrom(listType))
                return (JsonConverter)Activator.CreateInstance(typeof(ConcreteCollectionItemConverterDecorator<,,>).MakeGenericType(typeof(TItemConverter), listType, typeToConvert, itemType), new object [] { options, itemConverter });
        }
        // OK it's not an array and we can't find a parameterless constructor for the type.  We can serialize, but not deserialize.
        return (JsonConverter)Activator.CreateInstance(typeof(EnumerableItemConverterDecorator<,>).MakeGenericType(typeof(TItemConverter), typeToConvert, itemType), new object [] { options, itemConverter });
    }
    
    static (Type Type, bool IsArray, bool isSet) GetItemType(Type type)
    {
        // Quick reject for performance
        // Dictionary is not implemented. 
        if (type.IsPrimitive || type == typeof(string) || typeof(IDictionary).IsAssignableFrom(type))
            return (null, false, false);
        if (type.IsArray)
            return type.GetArrayRank() == 1 ? (type.GetElementType(), true, false) : (null, false, false);
        Type itemType = null;
        bool isSet = false;
        foreach (var iType in type.GetInterfacesAndSelf())
        {
            if (iType.IsGenericType)
            {
                var genType = iType.GetGenericTypeDefinition();
                if (genType == typeof(ISet<>))
                {
                    isSet = true;
                }
                else if (genType == typeof(IEnumerable<>))
                {
                    var thisItemType = iType.GetGenericArguments()[0];
                    if (itemType != null && itemType != thisItemType)
                        return (null, false, false); // type implements multiple enumerable types simultaneously. 
                    itemType = thisItemType;
                }
                else if (genType == typeof(IDictionary<,>))
                {
                    return (null, false, false); 
                }
            }
        }
        return (itemType, false, isSet);
    }
    
    abstract class CollectionItemConverterDecoratorBase<TEnumerable, TItem> : JsonConverter<TEnumerable> where TEnumerable : IEnumerable<TItem>
    {
        readonly JsonSerializerOptions modifiedOptions;

        public CollectionItemConverterDecoratorBase(JsonSerializerOptions options, TItemConverter converter)
        {
            // Clone the incoming options and insert the item converter at the beginning of the clone.
            // Then if converter is actually a JsonConverterFactory (e.g. JsonStringEnumConverter) then the correct JsonConverter<T> will be manufactured or fetched.
            this.modifiedOptions = new JsonSerializerOptions(options);
            this.modifiedOptions.Converters.Insert(0, converter);
        }

        protected TCollection BaseRead<TCollection>(ref Utf8JsonReader reader, Type typeToConvert) where TCollection : ICollection<TItem>, new()
        {
            if (reader.TokenType != JsonTokenType.StartArray)
                throw new JsonException(); // Unexpected token type
            var list = new TCollection();
            while (reader.Read())
            {
                if (reader.TokenType == JsonTokenType.EndArray)
                    break;
                list.Add(JsonSerializer.Deserialize<TItem>(ref reader, modifiedOptions));
            }
            return list;
        }

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

    sealed class ArrayItemConverterDecorator<TItem> : CollectionItemConverterDecoratorBase<TItem [], TItem>
    {
        public ArrayItemConverterDecorator(JsonSerializerOptions options, TItemConverter converter) : base(options, converter) { }
        public override TItem [] Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => BaseRead<List<TItem>>(ref reader, typeToConvert)?.ToArray();
    }

    sealed class ConcreteCollectionItemConverterDecorator<TCollection, TEnumerable, TItem> : CollectionItemConverterDecoratorBase<TEnumerable, TItem> 
        where TCollection : ICollection<TItem>, TEnumerable, new() 
        where TEnumerable : IEnumerable<TItem>
    {
        public ConcreteCollectionItemConverterDecorator(JsonSerializerOptions options, TItemConverter converter) : base(options, converter) { }
        public override TEnumerable Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => BaseRead<TCollection>(ref reader, typeToConvert);
    }

    sealed class EnumerableItemConverterDecorator<TEnumerable, TItem> : CollectionItemConverterDecoratorBase<TEnumerable, TItem> where TEnumerable : IEnumerable<TItem>
    {
        public EnumerableItemConverterDecorator(JsonSerializerOptions options, TItemConverter converter) : base(options, converter) { }
        public override TEnumerable Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) => throw new NotImplementedException(string.Format("Deserialization is not implemented for type {0}", typeof(TEnumerable)));
    }
}

public static class TypeExtensions
{
    public static IEnumerable<Type> GetInterfacesAndSelf(this Type type) => 
        (type ?? throw new ArgumentNullException()).IsInterface ? new[] { type }.Concat(type.GetInterfaces()) : type.GetInterfaces();
}

然后你将它应用到你的模型中，如下所示：

class Data
{
    [JsonConverter(typeof(ItemConverterDecorator<LibraryObjectConverter>))]
    public List<LibraryObject> lst { get; set; }
}

注意事项：

ItemConverterDecorator 不支持字典值。相比之下，Newtonsoft 的 ItemConverterType 属性确实支持字典值。
转换器不支持反序列化只读集合。
代码使用 .NET 5 中引入的 JsonSerializerOptions copy constructor。如果您使用的是 .NET Core 3.x，则需要将 new JsonSerializerOptions(options) 替换为代码以构建新的 JsonSerializerOptions 并手动复制每个属性。
在您的数据模型中，lst 属性有一个私有设置器：
```
public List<LibraryObject> lst { get; private set; }
```
.NET Core 3.x 不支持使用私有 setter 或 getter 对属性进行序列化。在 .NET 5 中，如果您使用 [JsonInclude] 标记属性是可能的
```
[JsonInclude]
public List<LibraryObject> lst { get; private set; }
```
请参阅：Non-public property accessors。

演示小提琴here.

【讨论】：

如何使用 System.Text.Json 引入 JsonConverter 装饰器？
@billy - 答案显示了如何将转换器应用于模型。或者我想你可以将它添加到 JsonSerializerOptions.Converters 例如像这样options.Converters.Add(new ItemConverterDecorator<MyCustomConverter>());
哦，对了，对不起，我以为是json.net代码。