Reading JSON nested objects with JsonUtility

Question

I currently have a JSON file:

{
    "locations": [
        {
            "name": "Mars",
            "type": "mining",
            "metals": 500,
            "gas": 0
        },
        {
            "name": "Jupiter",
            "type": "gas",
            "metals": 0,
            "gas": 1000
        }
    ]                   
}

And a script that reads it:

public class JSONReader : MonoBehaviour
{
    public TextAsset textJSON;

    [Serializable]
    public class Location
    {
        public string name;
        public string type;
        public int metals;
        public int gas;
    }

    [Serializable]
    public class LocationArray
    {
        public Location[] locations;  
    }

    public LocationArray mLocationArray = new LocationArray(); 
    public Location[] locationArray;

    void Start()
    {
        mLocationArray = JsonUtility.FromJson<LocationArray>(textJSON.text);
        locationArray = mLocationArray.locations;

        foreach (Location loc in locationArray)
        {
            Debug.Log(loc.name);
        }

I'm intending to modify the JSON file to add more locations and also nest the planets in star systems, however I'm not quite sure how to modify my script to accommodate the nesting. I've read that JSONUtility cannot output 2-dimensional arrays, however is that the only way that nested JSON data can be handled? Do I absolutely need to use a third-party library for this?

Answer 1

As @Evorlor mentioned in comments, you should using Newtonsoft Json (also known as Json.Net)

https://docs.unity3d.com/Packages/[email protected]/manual/index.html

It's the go-to default everywhere C# is used, it's cross-platform, very flexible and incredibly lightweight.

Once you've got that installed, all you need to do is define an object that has the same structure as your Json.

So... If you hypothetically wanted to support this Json:

[
    {
        "name": "Sol",
        "type": "star",
        "metals": 0,
        "gas": 0,
        "locations": [
            {
                "name": "Mars",
                "type": "mining",
                "metals": 500,
                "gas": 0
            },
            {
                "name": "Jupiter",
                "type": "gas",
                "metals": 0,
                "gas": 1000,
                "locations": [
                    {
                        "name": "Europa",
                        "type": "moon",
                        "metals": 0,
                        "gas": 0
                    },
                }
            }
        ]
    },
    {
        "name": "Proxima Centauri",
        "type": "star",
        "metals": 0,
        "gas": 0,
        "locations": [
            {
                "name": "Proxima Centauri C",
                "type": "mining",
                "metals": 500,
                "gas": 0
            }
        ]
    }
]

You could use a class structure like this:

public class Location
{
    public string name { get; set; }
    public string type { get; set; }
    public int metals { get; set; }
    public int gas { get; set; }

    public List<Location> locations { get; set; }
}

And if your json is in a string jsonConfig...

using Newtonsoft.Json;
...
var rootLocationList = JsonConvert.DeserializeObject<List<Location>>(jsonConfig);

rootLocationList is now a List<Location>

If a given location has child locations, there will be a populated list at locations, otherwise locations will be null.

Any location can have sub-locations, so you have almost¹ as many levels of nesting as you wish.

Note that I've changed the root of your Json to a list of locations. If you want other properties besides a list of locations, create a root object with a List<Location> locations property and whatever other properties you need).

You can also map using different names in the Json, should you wish:

public class Location
{
    ...
    [JsonProperty("locations")]
    public List<Location> childLocations { get; set; }
}

Check out the other parameters on the JsonProperty attribute to get an idea of what's possible.

¹ There's a default limit of 64 levels deep, but it's configurable.