Deserialize json with dynamic objects that starts with pattern

Question

I'm trying to deserialize some json that looks like this

{
   "id":"2021",
   "descriptions_bg":[
      "30231300",
      "30233160",
      "32420000",
      "30214000"
   ],
   "descriptions_cs":[
      "30231300",
      "30233160",
      "32420000",
      "30214000"
   ],
   "descriptions_da":[
      "30231300",
      "30233160",
      "32420000",
      "30214000"
   ],
   "official_title_bg":"П",
   "official_title_cs":"P",
   "official_title_da":"P",
   "auth_town_bg":"AuthTown",
   "auth_town_cs":"AuthTown",
   "auth_town_da":"AuthTown"
}

The problem here being, that there can come an infinite number of items in both descriptions_*, official_title_* and auth_town_* with different endings.

I've tried to make classes and members like public string official_title_* { get; set; }in C# to deserialize to with Newtonsoft Json, but that (of course) doesn't work.

Anyway to fix this?

Have you considered using Dynamic? https://www.newtonsoft.com/json/help/html/QueryJsonDynamic.htm — Gleb, Sep 08 '21 at 13:42
Does this answer help? [c# parsing relaxed json to make a tree](https://stackoverflow.com/q/45837283/880990). — Olivier Jacot-Descombes, Sep 08 '21 at 13:45
@Gleb Every time you use `dynamic`, a kitten dies, it's almost always a terrible idea to use it. — DavidG, Sep 08 '21 at 13:47

Krishna Varma · Answer 1 · 2021-09-08T14:06:10.003

1

The best option for you is to deserialize to Dictionary<string, JToken> and based on Key and Object Type you can write business logic. With the combination of Linq you can filter the Key

var json = File.ReadAllText("json1.json");

var dict = JsonConvert.DeserializeObject<Dictionary<string, JToken>>(json);

foreach(var item in dict.Where(x=>x.Key.StartsWith("descriptions_")))
{
    Console.WriteLine($"{item.Key} is type {item.Value.GetType()}");
}

foreach (var item in dict.Where(x => x.Key.StartsWith("auth_town_")))
{
    Console.WriteLine($"{item.Key} is type {item.Value.GetType()}");
}

edited Sep 08 '21 at 14:06

answered Sep 08 '21 at 14:00

Krishna Varma

4,238
2
10
25

I'd probably use `JToken` instead of `object`, but this will work. – DavidG Sep 08 '21 at 14:04
@DavidG make sense, I have updated the post with JToken – Krishna Varma Sep 08 '21 at 14:09
Thanks. So every key, also the known ones (for example id) needs to be handled this way? – perene Sep 08 '21 at 19:44

Jimi · Answer 2 · 2021-09-09T12:33:55.423

An alternative method, using a class object that defines each group of properties that have a common prefix as a Dictionary<string, TValue>.

The JSON is deserialized using a custom JsonConverter that maps each group of properties in the JSON to a Property of the class, using a Dictionary<string, string>:

Dictionary<string, string> map = new Dictionary<string, string>() {
    ["Descriptions"] = "descriptions_",
    ["OfficialTitles"] = "official_title_",
    ["AuthTowns"] = "auth_town_"
};

All properties in the JSON that map to a Property in the class are added to the corresponding Dictionary and the values converted to the Type defined by the class property.

Note: you need to adapt the mapper and class Properties to the JSON. You could make the procedure more generic using some logic to determine when Property Name in the JSON belongs to the same group and generate a new Dictionary<string, TValue> to add to the class by reflection.
Or simply add more Properties to the class off-line, if you find other groups.

Call it as: (possibly giving the class a less silly name :)

var result = new SimpleSequences().Deserialize(json);

Helper class object:

private class SimpleSequences
{
    public SimpleSequences() {
        Descriptions = new Dictionary<string, long[]>();
        OfficialTitles = new Dictionary<string, string>();
        AuthTowns = new Dictionary<string, string>();
    }

    public List<SimpleSequences> Deserialize(string json)
    {
        var options = new JsonSerializerSettings() {
            Converters = new[] { new SimpleSequencesConverter() }
        };
        return JsonConvert.DeserializeObject<List<SimpleSequences>>(json, options);
    }

    public int Id { get; set; }
    public Dictionary<string, long[]> Descriptions { get; set; }
    public Dictionary<string, string> OfficialTitles { get; set; }
    public Dictionary<string, string> AuthTowns { get; set; }
}

Custom JsonConverter:

This converter handles a single object or array of objects (as shown in your question), but always return a List<SimpleSequences> (which may contain a single object). Modify as required.

public class SimpleSequencesConverter : JsonConverter
{
    public override bool CanConvert(Type objectType) => true;

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType != JsonToken.StartArray && reader.TokenType != JsonToken.StartObject) {
            throw new Exception($"Unexpected Type. Expecting Array or Object, got {reader.TokenType}");
        }
        var elementsList = new List<SimpleSequences>();

        if (reader.TokenType == JsonToken.StartObject) {
            elementsList.Add(GetPropertyValues(JObject.Load(reader)));
        }
        else {
            while (reader.Read() && reader.TokenType != JsonToken.EndArray) {
                elementsList.Add(GetPropertyValues(JObject.Load(reader)));
            }
        }
        return elementsList;
    }

    private SimpleSequences GetPropertyValues(JToken token)
    {
        var element = new SimpleSequences();
        element.Id = token["id"].ToObject<int>();
        var descriptions = token.Children().Where(t => t.Path.StartsWith(map["Descriptions"]));

        foreach (JProperty p in descriptions) {
            element.Descriptions.Add(p.Path, p.Value.ToObject<long[]>());
        }

        var titles = token.Children().Where(t => t.Path.StartsWith(map["OfficialTitles"]));
        foreach (JProperty p in titles) {
            element.OfficialTitles.Add(p.Path, p.Value.ToString());
        }

        var authTowns = token.OfType<JToken>().Where(t => t.Path.StartsWith(map["AuthTowns"]));
        foreach (JProperty p in authTowns) {
            element.AuthTowns.Add(p.Path, p.Value.ToString());
        }
        return element;
    }

    public override bool CanWrite => false;

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        => throw new NotImplementedException();

    Dictionary<string, string> map = new Dictionary<string, string>() {
        ["Descriptions"] = "descriptions_",
        ["OfficialTitles"] = "official_title_",
        ["AuthTowns"] = "auth_town_"
    };
}

score 0 · Answer 3 · answered Sep 09 '21 at 08:55

Yet another solution could be to use several LINQ2JSON queries.

For instance, if you want to get all description_xyz collections in a single list
then you can do that like this:

var semiParsedJson = JObject.Parse(json);

var descriptionProperties = semiParsedJson.Properties()
    .Where(prop => prop.Name.StartsWith("descriptions_"));

var collectionOfDescriptions =
    from desc in descriptionProperties.Values()
    select ((JArray)desc).ToObject<IEnumerable<string>>();

var flattenedDescriptions = collectionOfDescriptions.
    SelectMany(desc => desc)
    .ToList();

We can semi parse the json by using JObject.Parse
We can perform some filtering based on the properties' Name field
We can then get all values form each description_xyz collections as IEnumerable<string>
We will have at this point a collection of collections IEnumerable<IEnumerable<string>>, which we can flatten with SelectMany
At very end we can materialize the query with ToList

Deserialize json with dynamic objects that starts with pattern

3 Answers3