使用不同的类型序列化/反序列化 System.Object

Question

我想知道如何为以下类实现自定义序列化程序/反序列化程序：

[JsonConverter(typeof(UnderlyingTypeConverter))]
public class ZoneProgramInput
{
    public string Name { get; set; }
    public Subject<object> InputSubject { get; }
    private IDisposable InputDisposable { get; set; }
    public Type Type { get; set; }
    public object Value { get; set; }
}

---

要求是我想使用存储在属性 Type 中的类型而不是类型 object 来序列化/反序列化属性Value(对象类型(。 因此，如果我有以下代码：

var zpi = new ZoneProgramInput() { Type = typeof(System.Drawing.Color), Value = System.Drawing.Color.Red };
var serializedZpi = JsonConvert.SerializeObject(zpi);
var deserializedZpi = JsonConvert.DeserializeObject<ZoneProgramInput>(serializedZpi);

变量 反序列化

Zpi 包含 zpi 的反序列化实例，以及反序列化的实例。值的类型应为 System.Drawing.Color 。如果没有自定义转换器，它会反序列化为字符串而不是System.Drawing.Color。请注意，我只是任意选择了System.Drawing.Color。这种类型可以是任何东西。

我有一个名为UnderlyingTypeConverter的转换器类(在上面的代码中被设置为ZoneProgramInput的转换器(：

public class UnderlyingTypeConverter : JsonConverter
{
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
    }
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
    }
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(ZoneProgramInput);
    }
}

我应该在 ReadJson/WriteJson 方法中填写什么，以确保 Value 属性使用存储在 Type 属性中的类型进行序列化和反序列化？我尝试在Google和StackOverflow中寻找ReadJson/WriteJson的示例，但我还没有找到任何可以帮助我以这种方式找到类型的东西。提前感谢您的帮助。

PS：我知道我可能会使用泛型，但我已经尝试过了。使 ZoneProgramInput 采用泛型类型参数，并使该类型的Value仍Value序列化/反序列化为字符串。我也尝试使用 C# dynamic 关键字，结果是一样的。此外，TypeNameHandling 显然不适用于定义为对象类型的东西。它只是将它们序列化为字符串而不是对象。

Answer 1

你需要这样做有点可惜，但我真的看不出解决方法。这是一个应该可以工作的转换器：

public class UnderlyingTypeConverter : JsonConverter
{
    public override void WriteJson(
        JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
    public override object ReadJson(
        JsonReader reader,
        Type objectType,
        object existingValue,
        JsonSerializer serializer)
    {
        var result = new ZoneProgramInput();
        // Deserialize into a temporary JObject
        JObject obj = serializer.Deserialize<JObject>(reader);
        // Populate the ZoneProgramInput object with the contents
        serializer.Populate(obj.CreateReader(), result);
        // Overwrite the "Value" property with the correct value based on the 
        // "Type" property.
        result.Value = 
            obj.GetValue("value", StringComparison.OrdinalIgnoreCase)
               .ToObject(result.Type, serializer);
        return result;
    }
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(ZoneProgramInput);
    }
    public override bool CanWrite
    {
        get { return false; }
    }
}

示例：https://dotnetfiddle.net/Zv57R8

Answer 2

我正在使用这种方式来序列化可以是不同类型的System.Object(可以对其进行修改以支持对象的集合(。

注意，如果可能位于该System.Object中的所有对象都有一些基类/接口 - 使用它而不是对象并启用此选项：https://www.newtonsoft.com/json/help/html/SerializeTypeNameHandling.htm

这是针对System.Object的情况：

public class SerializeMe
{
    [JsonConverter(typeof(ObjectJsonConverter))]
    public JsoSerializableObjectContainer VisualData { get; set; } = new JsoSerializableObjectContainer();
}
public class JsoSerializableObjectContainer
{
    public string ObjectTypeAssemblyName { get; set; }
    public string ObjectTypeName { get; set; }
    public string ObjectTypeData { get; set; }
    [JsonIgnore]
    public object Data { get; set; }
}
public class ObjectJsonConverter : JsonConverter
{
    private static Assembly[] _assemblies;
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var dataObj = (JsoSerializableObjectContainer) value;
        if (dataObj?.Data == null)
            return;
        var objType = dataObj.Data.GetType();
        dataObj.ObjectTypeName = objType.FullName;
        dataObj.ObjectTypeAssemblyName = objType.Assembly.FullName;
        dataObj.ObjectTypeData = JsonConvert.SerializeObject(dataObj.Data);
        var ser = JsonSerializer.Create();
        ser.Serialize(writer, dataObj);
    }
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var jsonSerializer = JsonSerializer.Create();
        var container = jsonSerializer.Deserialize<JsoSerializableObjectContainer>(reader);
        if (container != null)
        {
            if (_assemblies == null)
            {
                _assemblies = AppDomain.CurrentDomain.GetAssemblies();
            }
            var assembly = _assemblies.Single(t => t.FullName == container.ObjectTypeAssemblyName);
            var deserializationType = assembly.GetType(container.ObjectTypeName);
            if (deserializationType == null)
            {
                throw new JsonException(
                    $"Can't find type for object deserialization {container.ObjectTypeName}"); //Probably type was deleted from code
            }
            var myObject = JsonConvert.DeserializeObject(container.ObjectTypeData, deserializationType);
            container.Data = myObject;
            return container;
        }
        return null;
    }
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(JsoSerializableObjectContainer);
    }
}

测试代码：

        var ser = new SerializeMe();
        ser.VisualData.Data = (int)1;
        var serializationResult = JsonConvert.SerializeObject(ser);
        var deserializedObject = JsonConvert.DeserializeObject<SerializeMe>(serializationResult);

        ser.VisualData.Data = new System.Drawing.Rectangle(0, 1, 2, 3);
        serializationResult = JsonConvert.SerializeObject(ser);
        deserializedObject = JsonConvert.DeserializeObject<SerializeMe>(serializationResult);

注意：除了 ObjectTypeAssemblyName 和 ObjectTypeName，您只能使用 objType.AssemblyQualifiedName 中的第二个，但它可能会失败，因为它在搜索类型时还会检查程序集版本。更新包或 dll 版本更改后，它将无法找到类型。