C# 中使对象序列化/反序列化 Json 支持使用派生类型以及泛型的方式

来源：cnblogs　　作者：有什么不能一笑而过呢　　时间：2024/3/13 10:18:34　　对本文有异议

C# 中使对象序列化/反序列化 Json 支持使用派生类型以及泛型方式

废话

前言

为啥想写这个博客

最近自己写的框架有用到这个
```
  类似工作流,支持节点编码自定义,动态运行自定义.
  尽量减少动态解析这就需要确定类型.
```
有什么好的奇思妙想可以一起来讨论噢 (现在还是毛坯,测试各种可能性)
方便C#编码过程有泛型写起来舒服
编译期确定类型

RoslynPad 以及 .Dump() 方法说明

RoslynPad 是基于Roslyn 实现的跨平台C# 编辑器,简洁轻巧
支持nuget引用包
支持.NET框架版本切换

.Dump() 方法是 RoslynPad 支持的一个诊断方法,方便赋值并打印对象信息(看作是 Console.WriteLine就行但是 Dump方法会返回当前访问实例例如 int i = 1.Dump() ,i依然会被赋值为 1);

通过 `[JsonDerivedType]` 特性实现支持派生类型序列化/反序列化

首先定义 Base 以及它的派生类 Sub 并重写父类的GetValue方法


public class Sub:Base
{
    public object? Value { get; set; } = 15;
    public override object? GetValue() 
    {
        return Value;
    }
}
public class Base
{
   public virtual object? GetValue()
   {
        return default;
   }
}

当我们在程序中直接使用 Base 接收并调用 Sub 这个派生类的时候肯定没有任何问题(因为b运行时类型还是原来的Sub).

但是当我们如果需要将它序列化为json字符串传输的时候.

由于他已经脱离了原本类型的运行环境,只是一个json字符串,它当中没有任何关于它原来的类型信息记录,反序列化时json解析器根本不认识原来的运行时类型,他只知道应用定义的解析需要的类型是Base 而派生类 Sub.Value属性会被丢弃,但由于程序中很多地方都是用父类类型接收的,所以会导致信息的丢失.


using System.Text.Json;
using System.Text.Json.Serialization;
Base b = new Sub();
b.GetValue().Dump();
string json = JsonSerializer.Serialize(b).Dump();
Base desb = JsonSerializer.Deserialize<Base>(json).Dump();

输出


15 //b.GetValue().Dump();
{} // string json = JsonSerializer.Serialize(b).Dump();
Base //Base desb = JsonSerializer.Deserialize<Base>(json).Dump();

所以我们需要做的是在序列化/反序列化的时候生成/解析它原本类型的标记信息,让我们的应用识别到他的具体类型,这样在程序中使用父类接收的地方可以保证运行时类型正确.

System.Text.Json 提供了 JsonDerivedType 特性用以在父类中标注派生类以及序列化时候的标记名称


Base b = new Sub();
b.GetValue().Dump();
string json = JsonSerializer.Serialize(b).Dump();
Base desb = JsonSerializer.Deserialize<Base>(json).Dump();
public class Sub:Base
{
    public object? Value { get; set; } = 15;
    public override object? GetValue() 
    {
        return Value;
    }
}
[JsonDerivedType(typeof(Sub),"subType")] // 添加特性
public class Base
{
   public virtual object? GetValue()
   {
        return default;
   }
}

输出


15 //b.GetValue().Dump();
{"$type":"subType","Value":15} // string json = JsonSerializer.Serialize(b).Dump();
Sub   //Base desb = JsonSerializer.Deserialize<Base>(json).Dump();
  Value = 15
    Item = <null>
    ValueKind = Number
      value__ = 4

可以看到 b 在序列化为json字符串时带上了我们特性上指定的subType并赋值给了$type 属性
当我们反序列化为运行时对象时应用正确反序列化为了Sub对象.

但这只是最简单的一个场景, 我们日常使用最多的场景还是在继承的基础上还要加上泛型,但System.Text.Json中默认不支持泛型的序列化/反序列化.

当我们把代码改造为泛型之后会得到以下错误

无法支持泛型类型


[JsonDerivedType(typeof(SubT<>),"subType_G")]
public class Base<T>
{
   public virtual T? GetValue()
   {
        return default;
   }
}

异常

Specified type 'SubT`1[T]' is not a supported derived type for the polymorphic type 'Base`1[System.Int32]'. Derived types must be assignable to the base type, must not be generic and cannot be abstract classes or interfaces unless 'JsonUnknownDerivedTypeHandling.FallBackToNearestAncestor' is specified.

也无法支持不同泛型单独定义


  [JsonDerivedType(typeof(SubT<int>),"subType_Int")]
  [JsonDerivedType(typeof(SubT<bool>),"subType_Bool")]
  public class Base<T>
  {
     public virtual T? GetValue()
     {
          return default;
     }
  }

异常


Specified type 'SubT`1[System.Boolean]' is not a supported derived type for the polymorphic type 'Base`1[System.Int32]'. Derived types must be assignable to the base type, must not be generic and cannot be abstract classes or interfaces unless 'JsonUnknownDerivedTypeHandling.FallBackToNearestAncestor' is specified.

当只定义单一泛型基础类型时可以序列化,但反序列化依然异常仍需要单独定义读取,且父类及派生类都需要定义单一泛型类型实现定义(繁琐且不实用,谁定义泛型只会用一种基础类型的泛型啊)


  [JsonDerivedType(typeof(SubT<int>),"subType_Int")]
  public class SubT<T>:Base<T> 
  {
      public T TValue { get; set; }
      public override T? GetValue()
      {
          return TValue;
      }
  }
  [JsonDerivedType(typeof(Base<int>),"base_Int")]
  public class Base<T>
  {
     public virtual T? GetValue()
     {
          return default;
     }
  }

15 //b.GetValue().Dump();
{"$type":"subType_Int","TValue":15} // string json = JsonSerializer.Serialize(b).Dump();
Read unrecognized type discriminator id 'subType_Int'. Path: $ | LineNumber: 0 |  // Base<int> desb = JsonSerializer.Deserialize<Base<int>>(json).Dump();BytePositionInLine: 32.

通过 `[JsonConverter]`特性以及 `[KnowType]`特性标注派生类型实现支持自定义类型序列化

通过使用 System.Text.Json [JsonDerivedType] 可以实现简单的派生类型与基类转换.

但是遇到复杂的派生类型例如(泛型)则显得十分无力.

当我们需要支持复杂的类型转换的时候得需要用到另一个特性 JsonConvertAttribute 搭配自定义实现 JsonConvert<T> 了.

先定义一个特性用来标注序列化/反序列化过程中类型的定义包含泛型信息


// 自定义泛型类型名特性
public class GenericTypeNameAttribute:Attribute
{
    // 生成的属性名称
    public string GenericTypePropertyName { get; set; }
    
    // 泛型基础名称
    public string BaseName { get; set; }
    // 根据泛型基础类型T属性值
    public string GetGValue (string genericTypeName) => $"{GeneratePrefix}_{genericTypeName}";
    
    // 生成值前缀
    public string GeneratePrefix => $"{BaseName}_G";
}

然后将原来的 Base ,Sub 改为 Base<T>,Sub<T>,由于有了泛型可以将之前返回值从object 改为对应的泛型T,
并将 [GenericTypeName] 和关键的 [JsonConverter] 添加上


[GenericTypeName(GenericTypePropertyName = "$type",BaseName = nameof(Sub<T>))]
[JsonConverter(typeof(SubConverter<int>))]
public class Sub<T> :Base<T>
{
    public T Value { get; set; }
    
    public override T? GetValue() 
    {
        return Value;
    }
}
[GenericTypeName(GenericTypePropertyName = "$type",BaseName = nameof(Base<T>))]
[KnownType(typeof(Sub<>))]
[JsonConverter(typeof(BaseConverter<int>))]
public class Base<T>
{
   public virtual T? GetValue()
   {
        return default;
   }
}

并实现 JsonConverter<Base<T>> 和 JsonConverter<Sub<T>>

BaseConvert<T>


public class BaseConverter<T>:JsonConverter<Base<T>>
{
    public override Base<T>? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        var markerAttribute = typeToConvert.GetCustomAttribute<GenericTypeNameAttribute>()!;
        string genericTypeName = markerAttribute.GenericTypePropertyName!;
        
        string? typeName = default;
        
        T? tV = default;
        
        while(reader.Read())
        {
            if(reader.TokenType == JsonTokenType.EndObject)
                break;
                
            if(reader.TokenType == JsonTokenType.PropertyName)
            {
                string propertyName = reader.GetString() ?? throw new ArgumentException("Base<T> PropertyName");
                
                // 如果名称等于标注特性上的属性名称
                if(propertyName == genericTypeName)
                {
                    // 提前读取
                    reader.Read();
                    typeName = reader.GetString();
                    continue;
                }
            }else
            {
                JsonConverter<T> tConverter = (JsonConverter<T>)options.GetConverter(typeof(T));
                
                tV = tConverter.Read(ref reader,typeof(T),options);
            }
        }
        
        ArgumentException.ThrowIfNullOrWhiteSpace(typeName);
        
        //这里只演示 ,偷懒,如果有值就为 Sub<T> 如果要更通用的需要根据类型手动构造
        
        if(tV is not null)
        {
            return new Sub<T>{ Value = tV };
        }
        
        return new Base<T>();
    }
    public override void Write(Utf8JsonWriter writer, Base<T> value, JsonSerializerOptions options)
    {
    
        // 获取要写入的的类型
        var sourceType = value.GetType()!;
        
        // 获取 泛型 T 类型的名称
        string gernericName = sourceType.GenericTypeArguments.First().Name;
        
        // 我们自定义的标注特性
        // 可以缓存起来
        string genericTypeName = sourceType.GetCustomAttribute<GenericTypeNameAttribute>()!.GenericTypePropertyName!;
        string gernericBaseTypeName = sourceType.GetCustomAttribute<GenericTypeNameAttribute>()!.BaseName;
        
        // 如果是派生类型的泛型
        if(sourceType.GetGenericTypeDefinition() != typeof(Base<>))
        {
            var knowTypes =  Type.GetCustomAttributes<KnownTypeAttribute>();
            
            // 从 KnownType 中查找注册类型
            var targetType = knowTypes?.FirstOrDefault(
                    x => x.Type?.GetGenericTypeDefinition() == sourceType.GetGenericTypeDefinition());
            
            if(targetType != null && targetType.Type != null)
            {
                // 构建泛型类型
                var mkType = targetType.Type.MakeGenericType(sourceType.GenericTypeArguments[0]);
                
                // 调用对应已注册类型序列化方法
                writer.WriteRawValue(JsonSerializer.Serialize(value,mkType));
                return;
            }
        }
        
        // Base<T> 本身没任何属性 写入泛型类型就结束了
        writer.WriteStartObject();
        
        writer.WriteString(JsonNamingPolicy.CamelCase.ConvertName(genericTypeName),$"{gernericBaseTypeName}_G_{gernericName}");
        
        writer.WriteEndObject();
    }
}

SubConverter<T>


public class SubConverter<T>: JsonConverter<Sub<T>>
{
    public override Sub<T>? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        // 找到用于标记的特性
        string genericTypeName = typeToConvert.GetCustomAttribute<GenericTypeNameAttribute>()!.GenericTypePropertyName!;
        
        // 并未用到这个typeName 只是用来记录 可以根据具体需求使用
        string? typeName = default;
        
        T tV = default;
        
        // 当可以继续读取的时候
        while(reader.Read())
        {
            // 读到json对象末尾了 退出
            if(reader.TokenType == JsonTokenType.EndObject)
                break;
            
            // 读到属性名称记录下
            if(reader.TokenType == JsonTokenType.PropertyName)
            {
                string propertyName = reader.GetString();
                
                // 如果属性名称是特性标记中的名称
                if(propertyName == genericTypeName)
                {
                    // 手动继续读取
                    reader.Read();
                    // 获取到名称
                    typeName = reader.GetString();
                    // 并跳过当此循环 因为以及预读取过
                    continue;
                }
            }else
            {
                // 当初也在想怎么构建 泛型 T 的类型的实例
                // 后面参照官网示例
                // 是通过获取 T 对应的 JsonConverter 获取 并调用 Read 方法构建 (妙啊)
                // 例如: T为 int 则 JsonConverter<T> 其实就是获取 JsonConverter<int> 而基础类型基本都内置 
                // 所以不用专门去写 
                JsonConverter<T> tConverter = (JsonConverter<T>)options.GetConverter(typeof(T));
                
                tV = tConverter.Read(ref reader,typeof(T),options);
            }
        }
        
        ArgumentException.ThrowIfNullOrWhiteSpace(typeName);
        
        return new Sub<T>(){ Value = tV };
    }
    public override void Write(Utf8JsonWriter writer, Sub<T> value, JsonSerializerOptions options)
    {
         var sourceType = value.GetType()!;
        
        string genericName = sourceType.GenericTypeArguments.First().Name;
        
        var markerAttribute = sourceType.GetCustomAttribute<GenericTypeNameAttribute>()!;
        string genericTypePropName = markerAttribute.GenericTypePropertyName!;
        
        writer.WriteStartObject();
        
        if(value is Sub<string> st)
        {
            writer.WriteString("Value",st.Value);
        }else if(value is Sub<int> it)
        {
            writer.WriteNumber("Value",it.Value);
        }else if(value is Sub<bool> bt)
        {
            writer.WriteBoolean("Value",bt.Value);
        }
        
        writer.WriteString(JsonNamingPolicy.CamelCase.ConvertName(genericTypePropName),markerAttribute.GetGValue(genericName));
        writer.WriteEndObject();
    }
}

完成上述步骤之后我们就可以愉快的开始愉快的泛型序列化了......吗?

将我们的调用改为泛型调用


Base<int> i = new Sub<int>{ Value = 15 };
string json = JsonSerializer.Serialize(i).Dump();
Base<int> des = JsonSerializer.Deserialize<Base<int>>(json);
des.Dump();

输出


{"Value":15,"$type":"Sub_G_Int32"} // string json = JsonSerializer.Serialize(i).Dump();
Sub`1[System.Int32] // des.Dump();
  Value = 15

貌似没什么问题了...

等等...

泛型,那我改改类型试试

将上面Base<T>,Sub<T> 上的 JsonConvert<T> 泛型改为 bool 试试

输出


{"Value":true,"$type":"Sub_G_Boolean"} // string json = JsonSerializer.Serialize(i).
Sub`1[System.Boolean] // des.Dump();
  Value = True

好像也没问题

Ok, 那把 Base<T>,Sub<T> 上的 JsonConvert<T> 的 T 去掉不指定类型让他通用起来

......省略代码
[JsonConverter(typeof(BaseConverter<>))]
public class Base<T>
......省略代码

运行试试


Cannot create an instance of BaseConverter`1[T] because Type.ContainsGenericParameters is true.

啊 ?

竟然异常了,这不是玩我吗 ? 竟然 JsonConvertAttribute 传入的 Type 不支持泛型
从异常信息来看 ,好像是某种约束默认不让泛型参数

because Type.ContainsGenericParameters is true

经过一番查找最后在微软官方指引里发现了 JsonConverterFactory 这个类,用来
给支持泛型的房子加上最后一块砖

借由 `JsonConverterFactory` 实现支持泛型序列化/反序列化

继承并重写 JsonConverterFactory 的 CanConvert 以及 CreateConverter 方法


// 定义泛型转换器创建工厂
public abstract class GenericTypeConverterFactory : JsonConverterFactory
{
    // 泛型类型
    public abstract Type GenericType { get; }
    
    // 对应转换器泛型类型
    public abstract Type GenericJsonConvertType { get; }
    
    // 什么类型可以转换
    public override bool CanConvert(Type typeToConvert)
    {
        // 这里约束了只有泛型类型可以转换
        return typeToConvert.IsGenericType && typeToConvert.GetGenericTypeDefinition() == GenericType;
    }
    public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
    {
        // 获取泛型类型
        Type valueType = typeToConvert.GetGenericArguments()[0];
        // 手动构造泛型转换器的类型
        Type converterType = GenericJsonConvertType.MakeGenericType(valueType);
        
        // 获取对应的实例
        var ist = (JsonConverter?)Activator.CreateInstance(converterType);
        
        return ist;
    }
}
public sealed class BaseConverterFactory:GenericTypeConverterFactory
{
    public override Type GenericType => typeof(Base<>);
    public override Type GenericJsonConvertType => typeof(MyConverter<>);
}
public sealed class SubConverterFactory:GenericTypeConverterFactory
{
    public override Type GenericType => typeof(Sub<>);
    public override Type GenericJsonConvertType => typeof(SubConverter<>);
}

由于 JsonConverterFactory 是继承 JsonConverter 的 , 所以我们需要将 Base<T> 和 Sub<T> 上的 JsonConvert 替换为刚刚实现的两个工厂

......省略代码
[JsonConverter(typeof(BaseConverterFactory))]
public class Base<T>
......省略代码

运行 bool


{"Value":true,"$type":"Sub_G_Boolean"}
Sub`1[System.Boolean]
  Value = True

运行 int


{"Value":12,"$type":"Sub_G_Int32"}
Sub`1[System.Int32]
  Value = 12

运行 string


{"Value":"hello world","$type":"Sub_G_String"}
Sub`1[System.String]
  Value = hello world

完美 !!!!

结尾

上面就是我探索 json 泛型序列化的过程.

过程还是挺曲折

感觉这个需求挺小众,找了各个网站都没有这方面的解决方案.

不甘心的我对着微软的文档一个个特性研究,生怕错过一个关于这方面的能力.

最后的解决方案已经满足了我的需求

最后,上面的代码都是我想尽快发出博客手敲出来的,难免会有错误和没有达到最优性能的情况,但总体过程还是挺完整的.

原文链接：https://www.cnblogs.com/ablewang/p/18068949

友情链接：直通硅谷　点职佳　北美留学生论坛

JSON热门文章

FastJson实现驼峰下划线相互转换方法详解

Cesium中的图形技术：Fabric —— 材质JSON规范

vue如何加载本地json数据

Json常用序列化工具包大比拼

fastjson 1.2.80 漏洞浅析及利用payload

Golang语言JSON解码函数Unmarshal的使用

[Linux] 解决CentOS下Requires: libjson-c.so错误

解决layui的table插件无法多层级获取json数据的问题

C#使用Json.Net进行序列化和反序列化及定制化

golang如何修改json文件内容的方法示例

JSON推荐文章

在.NET Web API设置响应输出Json数据格式常用的两种方式

简单易懂的JSON框架

安装、学习protobuf

轻松上手Jackjson（珍藏版）

C# 中使对象序列化/反序列化 Json 支持使用派生类型以及泛型的方式

Asp .Net Core 系列：Asp .Net Core 集成 Newtonsoft.Json

在 JMeter 中使用 JSON 提取器提取特定条件下的值

ASP.NET Core Web API设置响应输出的Json数据格式的两种方式

基于jquery+html开发的json格式校验工具

手把手教你写一个JSON在线解析的前端网站1