Convert nested Firebase database object to C# object using Json.NET

Question

I need to convert firebase-ish data structure to C# object using JSON.Net library.

I store my data on Firebase Database like following;

 {
    "PoolDatas": {
        "-LGGJGTAv_DPtzkmjIbl": {
            "CoinType": 2,
            "PoolType": 4,
            "Alias": "First Alias",
            "Address": "0xAE12EF212",
            "Alarms": {
                "-LGsdsdv_DPtzkmjIbl": {
                    "Threshold": {
                        "Type": 2,
                        "Val": 100
                    },
                    "AlarmType": 3
                },
                "-LBAsdsdv_DPtzkmjIbl": {
                    "Threshold": {
                        "Type": 1,
                        "Val": 1
                    },
                    "AlarmType": 2
                }
            }
        },
        "-LEAJGTAv_DPtzkmjIbl": {
            "CoinType": 1,
            "PoolType": 1,
            "Alias": "Second Alias",
            "Address": "0xAeeeEF212",
            "Alarms": {
                "-LGsdsdv_DPtzkmjIbl": {
                    "Threshold": {
                        "Type": 10,
                        "Val": 120
                    },
                    "AlarmType": 1
                },
                "-LBAsdsdv_DPtzkmjIbl": {
                    "Threshold": {
                        "Type": 1,
                        "Val": 250
                    },
                    "AlarmType": 2
                }
            }
        }
    }
 }

All list objects have firebase generated ID. I cannot map this data to C# class because firebase IDs don't comply with the list structure.

Please see my model in C# side;

public class PoolData
{
     public string FirebaseId{ get; set; }
     public string Alias { get; set; }
     public PoolType PoolType { get; set; } //enum
     public CoinType CoinType { get; set; } //enum
     public string Address { get; set; }
     public List<Alarm> Alarms { get; set; }
}

public class Alarm
{
     public string FirebaseId{ get; set; }
     public AlarmType AlarmType{ get; set; } //enum
     public Threshold Threshold { get; set; } //object
}

public class Threshold
{
     public ThresholdType Type{ get; set; } //enum
     public int Value { get; set; }
}

In order to be able to convert Firebase-ish json into C# object I need a json like this;

{
   "PoolDatas": [
      {
         "FirebaseId": "-LGGJGTAv_DPtzkmjIbl",
         "CoinType": 1,
         "PoolType": 1,
         "Alias": "First Alias",
         "Alarms": [
            {
               "FirebaseId": "-LGsdsdv_DPtzkmjIbl",
               "Threshold": {
                  "Type": 1,
                  "Val": 1
               },
               "AlarmType": 1
            },
            {
               "FirebaseId": "-LBAsdsdv_DPtzkmjIbl",
               "Threshold": {
                  "Type": 1,
                  "Val": 1
               },
               "AlarmType": 2
            }
         ],
         "Address": "0xAE12EF212"
      },
      {
         "FirebaseId": "-LEAJGTAv_DPtzkmjIbl",
         "CoinType": 1,
         "PoolType": 1,
         "Alias": "First Alias",
         "Alarms": [
            {
               "FirebaseId": "-LGsdsdv_DPtzkmjIbl",
               "Threshold": {
                  "Type": 1,
                  "Val": 1
               },
               "AlarmType": 1
            },
            {
               "FirebaseId": "-LBAsdsdv_DPtzkmjIbl",
               "Threshold": {
                  "Type": 1,
                  "Val": 1
               },
               "AlarmType": 2
            }
         ],
         "Address": "0xAE12EF212"
      }
   ]
}

How can I obtain this json from the first one?

I tried several recursive processes using JObject loops but it didn't work.

Thanks in advance!

Answer 1

You can deserialize the JSON to a Dictionary<string, PoolData>, change each value so the key of the dictionary goes into the FirebaseId property, and then put it into an array, something like this:

class Origin
{
    public Dictionary<string, PoolData> PoolDatas { get; set; }
}

class Destination
{
    public PoolData[] PoolDatas { get; set; }
}


class Program
{
    static void Main(string[] args)
    {
        string json = File.ReadAllText("data.json");
        var data = JsonConvert.DeserializeObject<Origin>(json);
        var destination = new Destination();
        destination.PoolDatas = data.PoolDatas.Select(i =>
        {
            i.Value.FirebaseId = i.Key;
            return i.Value;
        }).ToArray();

    }
}

You will need to install and import the Json.Net package using Newtonsoft.Json;.

EDIT: as mentioned in the comments, this will not work for nested objects. For that scenario, maybe you could use a custom serializer, something like this:

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace ConsoleApp1
{

    public interface IFirebaseObject
    {
        string FirebaseId { get; set; }
    }

    public class PoolData
    {
        public string FirebaseId { get; set; }
        public string Alias { get; set; }
        public string Address { get; set; }
        [JsonConverter(typeof(MapToArrayConverter<Alarm>))]
        public List<Alarm> Alarms { get; set; }
    }

    public class Alarm: IFirebaseObject
    {
        public string FirebaseId { get; set; }
        public Threshold Threshold { get; set; } //object
    }

    public class Threshold
    {
        public int Value { get; set; }
    }

    class Origin
    {
        public Dictionary<string, PoolData> PoolDatas { get; set; }
    }

    class Destination
    {
        public PoolData[] PoolDatas { get; set; }
    }


    class Program
    {
        static void Main(string[] args)
        {
            string json = File.ReadAllText("data.json");
            var data = JsonConvert.DeserializeObject<Origin>(json);
            var destination = new Destination();
            destination.PoolDatas = data.PoolDatas.Select(i =>
            {
                i.Value.FirebaseId = i.Key;
                return i.Value;
            }).ToArray();
        }
    }


    public class MapToArrayConverter<T> : JsonConverter where T : IFirebaseObject
    {
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.StartObject)
            {
                JObject item = JObject.Load(reader);
                Dictionary<string, T> value = JsonConvert.DeserializeObject<Dictionary<string, T>>(item.ToString());
                // TODO also consider single values instead of lists
                return value.Select(i =>
                {
                    i.Value.FirebaseId = i.Key;
                    return i.Value;
                }).ToList();
            } else
            {
                return null;
            }
        }

        public override bool CanConvert(Type objectType)
        {
            // TODO validate the object type
            return true;
        }

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            // TODO implement the reverse method to also write
            throw new NotImplementedException();
        }
    }
}

But as you can see the solution starts to get somewhat complex. Unless you need to do this for many types, maybe manually converting would be less time consuming and simpler to maintain.