CODEWITHSUNDEEP
javac#jsonjacksonjson.net
mentos
mentos

Reputation: 33

How can I make reference handling syntax from Jackson and JSON.net compatible?

I have a server that produces the following JSON with Jackson.

{
  "$id" : 1,
  "employees" : [
    {
        "$id" : 2,
        "name" : "John Rambo",
    },
    2                     // Jackson: reference by ID only
  ]
}

The list of employees contains the same employee twice. Jackson correctly references the object by it's ID the second time.

I want to deserialize this in a client that uses JSON.net, but this won't work because JSON.net expects me to have the reference wrapped in a json object with a $ref property like this:

{
  "$id": "1",
  "employees" : [
    {
      "$id": "2",
      "name": "John Rambo"
    },
    {
     "$ref": "2"              // JSON.net: reference wrapped in JSON object
    }
  ]
}

Is there a way to make JSON.net correctly consume the Jackson syntax either by configuration or by implementing a custom deserializer?

Upvotes: 3

Views: 489

Answers (1)

Andrew Whitaker
Andrew Whitaker

Reputation: 126072

Here's a custom converter that should work:

public class EmployeeConverter : 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)
    {
        List<Employee> employees = null;

        if (reader.TokenType == JsonToken.StartArray)
        {
            JArray arr = serializer.Deserialize<JArray>(reader);

            employees = new List<Employee>(arr.Count);

            var employeeMap = new Dictionary<int, Employee>();

            foreach (var item in arr)
            {
                if (item.Type == JTokenType.Object)
                {
                    var employee = item.ToObject<Employee>();
                    employees.Add(employee);

                    int id = item["$id"].ToObject<int>();
                    employeeMap.Add(id, employee);
                }
                else if (item.Type == JTokenType.Integer)
                {
                    Employee employee = null;

                    int id = item.ToObject<int>();

                    if (employeeMap.TryGetValue(id, out employee))
                    {
                        employees.Add(employee);
                    }
                }
            }
        }

        return employees;
    }

    public override bool CanRead
    {
        get { return true; }
    }

    public override bool CanConvert(Type objectType)
    {
        return false;
    }
}

... and here's how you'd use it:

public class Company
{
    public Company()
    {
        this.Employees = new List<Employee>();
    }

    [JsonConverter(typeof(EmployeeConverter))]
    public List<Employee> Employees { get; set; }
}

Example: https://dotnetfiddle.net/XooyQC

Basically use a custom converter to deserialize the entire array. First, deserialize the array to a JArray, then inspect each element of the JArray to see if it's a reference or a new object.

Upvotes: 1

Related Questions