System.Text.Json：如何为集合应用 JsonConverter，并为集合的项目提供自定义转换器？

Question

我有一个类想要序列化为 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 的解决方案，所以我可以使用“默认转换器”。
为了便于代码使用者使用，我更喜欢添加标签\逻辑，而不是使用上述解决方案。

Answer 1

您正在寻找的内容相当于 Newtonsoft 的JsonPropertyAttribute.ItemConverterType：

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

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

下面的代码JsonConverterFactory正是这样做的：

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

    public override bool CanConvert(Type typeToConvert) => GetItemType(typeToConvert).ItemType is var itemType && itemType != null && itemConverter.CanConvert(itemType);

    public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
    {
        var (itemType, isArray, isSet) = GetItemType(typeToConvert);
        if (itemType == null)
            throw new NotImplementedException();
        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? ItemType, 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 JsonConverter<TItem> innerConverter;

        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.
            var modifiedOptions = new JsonSerializerOptions(options);
            modifiedOptions.Converters.Insert(0, converter);
            innerConverter = (JsonConverter<TItem>)modifiedOptions.GetConverter(typeof(TItem));
        }

        protected TCollection BaseRead<TCollection>(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) where TCollection : ICollection<TItem>, new()
        {
            if (reader.TokenType != JsonTokenType.StartArray)
                throw new JsonException(); // Unexpected token type.  JsonTokenType.Null is handled by the framework, unless we set HandleNull => true (which we didn't).
            var list = new TCollection();
            while (reader.Read())
            {
                if (reader.TokenType == JsonTokenType.EndArray)
                    break;
                var item = innerConverter.Read(ref reader, typeof(TItem), options);
                // TODO: optionally add checks to make sure innerConverter correctly advanced the reader to the end of the current token.
                list.Add(item!);
            }
            return list;
        }

        public sealed override void Write(Utf8JsonWriter writer, TEnumerable value, JsonSerializerOptions options)
        {
            writer.WriteStartArray();
            foreach (var item in value)
                innerConverter.Write(writer, item, options);
            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, options).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, options);
    }

    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复制构造函数。如果您使用的是 .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; }
  

  请参阅：非公共属性访问器。

演示小提琴在这里。