Json.NET 第三方类型的自定义序列化/反序列化

Question

我想将 OpenTK 库的向量与 JSON 相互转换。我认为它的工作方式只是制作一个自定义的 JsonConverter，所以我这样做了：

class VectorConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(Vector4);
    }
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var obj = JToken.Load(reader);
        if (obj.Type == JTokenType.Array)
        {
            var arr = (JArray)obj;
            if (arr.Count == 4 && arr.All(token => token.Type == JTokenType.Float))
            {
                return new Vector4(arr[0].Value<float>(), arr[1].Value<float>(), arr[2].Value<float>(), arr[3].Value<float>());
            }
        }
        return null;
    }
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var vector = (Vector4)value;
        writer.WriteStartArray();
        writer.WriteValue(vector.X);
        writer.WriteValue(vector.Y);
        writer.WriteValue(vector.Z);
        writer.WriteValue(vector.W);
        writer.WriteEndArray();
    }
}

现在，写作部分对我来说非常简单（我认为？当序列化程序遍历对象时，如果遇到 CanConvert 方法以 true 响应的对象，它会让我的自定义序列化程序将其转换为 JSON。这行得通。

我真正没有得到的是另一种方式。由于当它只是用 JSON 文字编写时，无法知道它是什么类型，我想我必须自己分析对象并确定它是否实际上是 Vector 对象。我编写的代码可以工作，但如果检查失败，我不知道该怎么办。我如何告诉反序列化程序这不是我知道如何翻译的对象之一，它应该在其上执行默认操作？

我是否错过了整个事情如何运作的东西？

Answer 1

在反序列化期间，Json.Net 查看要反序列化为的类，以确定要创建的类型，以及是否调用转换器。 因此，如果反序列化为具有 Vector4 属性的类，则将调用转换器。 如果您反序列化为模糊的东西，例如 dynamic 或 object 或 JObject ，那么 Json.Net 将不知道调用您的转换器，因此反序列化的对象层次结构将不包含任何Vector4实例。

让我们举一个简单的例子来使这个概念更加清晰。 假设我们有这个 JSON：

{
    "PropA": [ 1.0, 2.0, 3.0, 4.0 ],
    "PropB": [ 5.0, 6.0, 7.0, 8.0 ]
}

显然，上述 JSON 中的"PropA"和"PropB"都可以代表一个Vector4（或者至少我从您的转换器代码推断为Vector4 - 我实际上并不熟悉 OpenTK 库）。 但是，正如您所注意到的，JSON 中没有类型信息表明任一属性都应该是 Vector4 .

让我们尝试使用转换器将 JSON 反序列化为以下类。 在这里，PropA必须包含 Vector4 或 null，因为它是强类型的，而PropB可以是任何内容。

public class Tester
{
    public Vector4 PropA { get; set; }
    public object PropB { get; set; }
}

以下是测试代码：

class Program
{
    static void Main(string[] args)
    {
        string json = @"
        {
            ""PropA"": [ 1.0, 2.0, 3.0, 4.0 ],
            ""PropB"": [ 5.0, 6.0, 7.0, 8.0 ]
        }";
        try
        {
            Tester t = JsonConvert.DeserializeObject<Tester>(json),
                                              new VectorConverter());
            DumpObject("PropA", t.PropA);
            DumpObject("PropB", t.PropB);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.GetType().Name + ": " + ex.Message);
        }
    }
    static void DumpObject(string prop, object obj)
    {
        if (obj == null)
        {
            Console.WriteLine(prop + " is null");
        }
        else
        {
            Console.WriteLine(prop + " is a " + obj.GetType().Name);
            if (obj is Vector4)
            {
                Vector4 vector = (Vector4)obj;
                Console.WriteLine("   X = " + vector.X);
                Console.WriteLine("   Y = " + vector.Y);
                Console.WriteLine("   Z = " + vector.Z);
                Console.WriteLine("   W = " + vector.W);
            }
            else if (obj is JToken)
            {
                foreach (JToken child in ((JToken)obj).Children())
                {
                    Console.WriteLine("   (" + child.Type + ") " 
                                             + child.ToString());
                }
            }
        }
    }
}
// Since I don't have the OpenTK library, I'll use the following class
// to stand in for `Vector4`.  It should look the same to your converter.
public class Vector4
{
    public Vector4(float x, float y, float z, float w)
    {
        X = x;
        Y = y;
        Z = z;
        W = w;
    }
    public float W { get; set; }
    public float X { get; set; }
    public float Y { get; set; }
    public float Z { get; set; }
}

当我运行测试代码时，这是我得到的输出：

PropA is a Vector4
   X = 1
   Y = 2
   Z = 3
   W = 4
PropB is a JArray
   (Float) 5
   (Float) 6
   (Float) 7
   (Float) 8

所以你可以看到，对于PropA，Json.Net 使用转换器来创建Vector4实例（否则我们会得到一个 JsonSerializationException），而对于PropB，它没有（否则，我们会在输出中看到PropB is a Vector4）。

至于您问题的第二部分，如果您的转换器获得的 JSON 不是它所期望的，该怎么办。 您有两个选择 - 返回 null，就像您正在做的那样，或者抛出异常（例如 JsonSerializationException）。 如果正在调用转换器，则知道 Json.Net 正在尝试填充Vector4对象。 如果不是，那么您的转换器就不会被调用。 因此，如果由于 JSON 错误而无法填充它，则必须确定是否可以接受Vector4为 null，或者最好出错。 这是一个设计决策，取决于您在项目中尝试执行的操作。

我解释清楚了吗？