Deserialize jagged array with unknown dimensions

Question

I'm currently trying to parse a Json file in Unity using Json.NET and can parse 80% of the data at the moment. I've come across a section that is formatted like this.

{
  "features": [
    {
      "coordinates": [
        [
          [ 1, 1 ],
          [ 2, 2 ]
        ]
      ]
    },
    {
      "coordinates": [
        [ 1, 1 ],
        [ 2, 2 ],
        [ 3, 3 ]
      ]
    },
    {
      "coordinates": [
        [
          [ 1, 2 ],
          [ 1, 2 ]
        ]
      ]
    },
    {
      "coordinates": [
        [
          [
            [ 1, 2 ],
            [ 1, 2 ]
          ]
        ]
      ]
    }
  ]
}

The coordinates array may contain an unknown number of coordinates and it will be a jagged array with unknown dimensions as well. I'm unable to parse it as I'm not very well versed with Json deserialization.

Any help on how to approach this appreciated.

Answer 1

I'm not sure how much variety is in your data but here's a rough idea using recursion.

    void ParseCoordinateJSON()
    {
        var coordinates = new List<int[]>();
        var parsed = JObject.Parse(rawJson);

        var featureArray = parsed.SelectToken("features");
        var coordArray = featureArray.Children();

        coordArray.ToList().ForEach(n => ExtractCoordinates(n.SelectToken("coordinates"), coordinates));

        Debug.Log(string.Join("\n", coordinates.Select(c => $"({string.Join(", ", c)})")));
    }

    void ExtractCoordinates(JToken node, List<int[]> coordinates)
    {
        if (node == null)
        {
            return;
        }

        if (node.Children().Any(n => n.Type == JTokenType.Integer))
        {
            coordinates.Add(node.Children().Select(n => n.Value<int>()).ToArray());
            return;
        }

        node.Children().Where(n => n.Type == JTokenType.Array).ToList().ForEach(n => ExtractCoordinates(n, coordinates));
    }

Edit: Here's it is without linq which might be easier to follow:

void ParseCoordinateJSONNoLinq()
{
    var coordinates = new List<int[]>();
    var parsed = JObject.Parse(rawJSON);

    var featureArray = parsed.SelectToken("features");

    // These will be the objects with a "coordinates" key and an array value.
    var coordArray = featureArray.Children();

    foreach(var node in coordArray)
    {
        ExtractCoordinatesNoLinq(node.SelectToken("coordinates"), coordinates);
    }

    Console.WriteLine(string.Join("\n", coordinates.Select(c => $"({string.Join(", ", c)})")));
}

void ExtractCoordinatesNoLinq(JToken node, List<int[]> coordinates)
{
    var intValues = new List<int>();

    // Step through each child of this node and do something based on its node type.
    foreach(var child in node.Children())
    {
        // If the child is an array, call this method recursively.
        if (child.Type == JTokenType.Array)
        {
            // Changes to the coordinates list in the recursive call will persist.
            ExtractCoordinatesNoLinq(child, coordinates);

        // The child type is an integer, add it to the int values.
        } else if (child.Type == JTokenType.Integer)
        {
            intValues.Add(child.Value<int>());
        }
    }

    // Since we found int values at this level, add them to the shared coordinates list.
    if (intValues.Count > 0)
    {
        coordinates.Add(intValues.ToArray());
    }
}

If the rest of your data is reliable, I would use typical data objects and de-serialize to them then add something like the above as a Custom JSON Converter for an object representing the jagged array.

public class MyDataObject {
  public string SomeField {get; set;}

  public Vector2 Position {get; set;}

  [JsonProperty("features")]
  public JaggedFeatures {get; set;}
}

public class JaggedFeatures {
  public List<int[]> Coordinates {get; set;}
}

//...

JsonConvert.Deserialize<MyDataObject>(rawJSON, new JaggedFeaturesConverter())