用于集合的JsonConverter和用于集合项目的自定义转换器

问题描述

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

解决方法

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

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

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

以下 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,itemConverter });
        if (isSet)
        {
            var setType = typeof(HashSet<>).MakeGenericType(itemType);
            if (typeToConvert.IsAssignableFrom(setType))
                return (JsonConverter)Activator.CreateInstance(typeof(ConcreteCollectionItemConverterDecorator<,setType,itemConverter });
        }
        else
        {
            var listType = typeof(List<>).MakeGenericType(itemType);
            if (typeToConvert.IsAssignableFrom(listType))
                return (JsonConverter)Activator.CreateInstance(typeof(ConcreteCollectionItemConverterDecorator<,listType,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<,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);
        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); // type implements multiple enumerable types simultaneously. 
                    itemType = thisItemType;
                }
                else if (genType == typeof(IDictionary<,>))
                {
                    return (null,false); 
                }
            }
        }
        return (itemType,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>,new() 
        where TEnumerable : IEnumerable<TItem>
    {
        public ConcreteCollectionItemConverterDecorator(JsonSerializerOptions options,converter) { }
        public override TEnumerable Read(ref Utf8JsonReader reader,JsonSerializerOptions options) => BaseRead<TCollection>(ref reader,typeToConvert);
    }

    sealed class EnumerableItemConverterDecorator<TEnumerable,TItem> where TEnumerable : IEnumerable<TItem>
    {
        public EnumerableItemConverterDecorator(JsonSerializerOptions options,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 属性有一个私有 setter：
```
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。

c#c#collections json jsonconvert

用于集合的JsonConverter和用于集合项目的自定义转换器

问题描述

解决方法

相关问答