在json反序列化过程中确定对象“类型”

Question

While trying to de-serialize a complex JSON object (JIRA issue) into an object containing a dictionary of type string-Field I've hit a bit of a bump.

While I can de-serialize various pre-determined object types (standard), I'm having a bit of a harder time with the custom fields, which could be of various types (they all begin with customfield_ followed by a set of numbers).

The custom fields can be floats, strings, booleans, objects and arrays of objects. The latter of these is causing me issues since I can't seem to determine what the object is before I de-serialize it.

I've searched for a way to perhaps "peek" at the data in the object before de-serializing as one of the fields contains information specific to it's type. This is all so I can determine the type of the object and tell Json.Net what to de-serialize it as.

I've considered parsing the JSON string before serialization to get the information, or maybe just when hitting this particular case, but maybe there is a better way?

Thanks in advance for any advice on this.

Answer 1

You can deserialize to an object with Json.Net. Here's a quick and dirty example:

using System;
using Newtonsoft.Json;

namespace Sandbox
{
class Program
{
    private static void Main(string[] args)
    {
       var nestDto = new Dto
        {
            customfield_1 = 20,
            customfield_2 = "Test2"
        };

        var dto = new Dto
        {
            customfield_1 = 10,
            customfield_3 = new[] { nestDto },
            customfield_2 = "Test"
        };

        var jsonString = JsonConvert.SerializeObject(dto);
        Console.WriteLine(jsonString);

        var fromJsonString = JsonConvert.DeserializeObject<Dto>(jsonString);

        Console.WriteLine(fromJsonString.customfield_3[0].customfield_2); //Outputs Test2
        Console.ReadKey();
    }
}

class Dto
{
    public int customfield_1 { get; set; }
    public string customfield_2 { get; set; }
    public Dto[] customfield_3 { get; set; }
}
}

Answer 2

Instead of peaking, you can deserialize as the same type as JSON.net uses for ExtensionData explicitly. For example:

if (reader.TokenType == JsonToken.StartArray)
{
    var values = serializer.Deserialize<List<Dictionary<string, JToken>>>(reader);
    objectContainer = ClassifyAndReturn(values); 
}

private ObjectType ClassifyAndReturn(List<Dictionary<string, JToken>> values)
{
    if (values.First().ContainsKey("self"))
    {
        string self = values.First()["self"].Value<string>();
        if (self.Contains("customFieldOption"))
        //... Then go into a series of if else cases to determine the object. 

The representation of the objects are given as a Dictionary of string to JToken, which can then easily be checked and assigned manually or in some cases automatically deserialized (in the case one of the fields is another object).

Here is what an object constructor could look like:

internal myobject(Dictionary<string, JToken> source)
{
    Self = source["self"].Value<string>();
    Id = source["id"].Value<string>();
    Value = source["value"].Value<string>();
}